rhodes 2.0.3 → 2.1.0

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/processor/null.c

@@ -0,0 +1,62 @@
+/*------------------------------------------------------------------------
+ *  Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+ *
+ *  This file is part of the ZBar Bar Code Reader.
+ *
+ *  The ZBar Bar Code Reader is free software; you can redistribute it
+ *  and/or modify it under the terms of the GNU Lesser Public License as
+ *  published by the Free Software Foundation; either version 2.1 of
+ *  the License, or (at your option) any later version.
+ *
+ *  The ZBar Bar Code Reader 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 Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser Public License
+ *  along with the ZBar Bar Code Reader; if not, write to the Free
+ *  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *  Boston, MA  02110-1301  USA
+ *
+ *  http://sourceforge.net/projects/zbar
+ *------------------------------------------------------------------------*/
+
+#include "../processor.h"
+
+static inline int null_error (void *m,
+                              const char *func)
+{
+    return(err_capture(m, SEV_ERROR, ZBAR_ERR_UNSUPPORTED, func,
+                       "not compiled with output window support"));
+}
+
+int _zbar_processor_open (zbar_processor_t *proc,
+                          char *name,
+                          unsigned w,
+                          unsigned h)
+{
+    return(null_error(proc, __func__));
+}
+
+int _zbar_processor_close (zbar_processor_t *proc)
+{
+    return(null_error(proc, __func__));
+}
+
+int _zbar_processor_set_visible (zbar_processor_t *proc,
+                                 int vis)
+{
+    return(null_error(proc, __func__));
+}
+
+int _zbar_processor_set_size (zbar_processor_t *proc,
+                              unsigned width,
+                              unsigned height)
+{
+    return(null_error(proc, __func__));
+}
+
+int _zbar_processor_invalidate (zbar_processor_t *proc)
+{
+    return(null_error(proc, __func__));
+}

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/processor/posix.c

@@ -0,0 +1,337 @@
+/*------------------------------------------------------------------------
+ *  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+ *
+ *  This file is part of the ZBar Bar Code Reader.
+ *
+ *  The ZBar Bar Code Reader is free software; you can redistribute it
+ *  and/or modify it under the terms of the GNU Lesser Public License as
+ *  published by the Free Software Foundation; either version 2.1 of
+ *  the License, or (at your option) any later version.
+ *
+ *  The ZBar Bar Code Reader 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 Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser Public License
+ *  along with the ZBar Bar Code Reader; if not, write to the Free
+ *  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *  Boston, MA  02110-1301  USA
+ *
+ *  http://sourceforge.net/projects/zbar
+ *------------------------------------------------------------------------*/
+
+#include "processor.h"
+#include "posix.h"
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+
+
+static inline int proc_sleep (int timeout)
+{
+    assert(timeout > 0);
+    struct timespec sleepns, remns;
+    sleepns.tv_sec = timeout / 1000;
+    sleepns.tv_nsec = (timeout % 1000) * 1000000;
+    while(nanosleep(&sleepns, &remns) && errno == EINTR)
+        sleepns = remns;
+    return(1);
+}
+
+int _zbar_event_init (zbar_event_t *event)
+{
+    event->state = 0;
+    event->pollfd = -1;
+#ifdef HAVE_LIBPTHREAD
+    pthread_cond_init(&event->cond, NULL);
+#endif
+    return(0);
+}
+
+void _zbar_event_destroy (zbar_event_t *event)
+{
+    event->state = -1;
+    event->pollfd = -1;
+#ifdef HAVE_LIBPTHREAD
+    pthread_cond_destroy(&event->cond);
+#endif
+}
+
+/* lock must be held */
+void _zbar_event_trigger (zbar_event_t *event)
+{
+    event->state = 1;
+#ifdef HAVE_LIBPTHREAD
+    pthread_cond_broadcast(&event->cond);
+#endif
+    if(event->pollfd >= 0) {
+        unsigned i = 0; /* unused */
+        if(write(event->pollfd, &i, sizeof(unsigned)) < 0)
+            perror("");
+        event->pollfd = -1;
+    }
+}
+
+#ifdef HAVE_LIBPTHREAD
+
+/* lock must be held */
+int _zbar_event_wait (zbar_event_t *event,
+                      zbar_mutex_t *lock,
+                      zbar_timer_t *timeout)
+{
+    int rc = 0;
+    while(!rc && !event->state) {
+        if(!timeout)
+            rc = pthread_cond_wait(&event->cond, lock);
+        else {
+            struct timespec *timer;
+# if _POSIX_TIMERS > 0
+            timer = timeout;
+# else
+            struct timespec tmp;
+            tmp.tv_sec = timeout->tv_sec;
+            tmp.tv_nsec = timeout->tv_usec * 1000;
+            timer = &tmp;
+# endif
+            rc = pthread_cond_timedwait(&event->cond, lock, timer);
+        }
+    }
+
+    /* consume/reset event */
+    event->state = 0;
+
+    if(!rc)
+        return(1); /* got event */
+    if(rc == ETIMEDOUT)
+        return(0); /* timed out */
+    return(-1); /* error (FIXME save info) */
+}
+
+int _zbar_thread_start (zbar_thread_t *thr,
+                        zbar_thread_proc_t *proc,
+                        void *arg,
+                        zbar_mutex_t *lock)
+{
+    if(thr->started || thr->running)
+        return(-1/*FIXME*/);
+    thr->started = 1;
+    _zbar_event_init(&thr->notify);
+    _zbar_event_init(&thr->activity);
+
+    int rc = 0;
+    _zbar_mutex_lock(lock);
+    if(pthread_create(&thr->tid, NULL, proc, arg) ||
+       _zbar_event_wait(&thr->activity, lock, NULL) < 0 ||
+       !thr->running) {
+        thr->started = 0;
+        _zbar_event_destroy(&thr->notify);
+        _zbar_event_destroy(&thr->activity);
+        /*rc = err_capture_num(proc, SEV_ERROR, ZBAR_ERR_SYSTEM,
+          __func__, "spawning thread", rc);*/
+        rc = -1/*FIXME*/;
+    }
+    _zbar_mutex_unlock(lock);
+    return(rc);
+}
+
+int _zbar_thread_stop (zbar_thread_t *thr,
+                       zbar_mutex_t *lock)
+{
+    if(thr->started) {
+        thr->started = 0;
+        _zbar_event_trigger(&thr->notify);
+        while(thr->running)
+            /* FIXME time out and abandon? */
+            _zbar_event_wait(&thr->activity, lock, NULL);
+        pthread_join(thr->tid, NULL);
+        _zbar_event_destroy(&thr->notify);
+        _zbar_event_destroy(&thr->activity);
+    }
+    return(0);
+}
+
+#else
+
+int _zbar_event_wait (zbar_event_t *event,
+                      zbar_mutex_t *lock,
+                      zbar_timer_t *timeout)
+{
+    int rc = !event->state;
+    if(rc) {
+        if(!timeout)
+            /* FIXME was that error or hang? */
+            return(-1);
+
+        int sleep = _zbar_timer_check(timeout);
+        if(sleep)
+            proc_sleep(sleep);
+    }
+
+    rc = !event->state;
+
+    /* consume/reset event */
+    event->state = 0;
+
+    return(rc);
+}
+
+#endif
+
+/* used by poll interface.  lock is already held */
+static int proc_video_handler (zbar_processor_t *proc,
+                               int i)
+{
+    _zbar_mutex_lock(&proc->mutex);
+    _zbar_processor_lock(proc);
+    _zbar_mutex_unlock(&proc->mutex);
+
+    zbar_image_t *img = NULL;
+    if(proc->streaming) {
+        /* not expected to block */
+        img = zbar_video_next_image(proc->video);
+        if(img)
+            _zbar_process_image(proc, img);
+    }
+
+    _zbar_mutex_lock(&proc->mutex);
+    _zbar_processor_unlock(proc, 0);
+    _zbar_mutex_unlock(&proc->mutex);
+    if(img)
+        zbar_image_destroy(img);
+    return(0);
+}
+
+static inline void proc_cache_polling (processor_state_t *state)
+{
+    /* make a thread-local copy of polling data */
+    int n = state->thr_polling.num = state->polling.num;
+    alloc_polls(&state->thr_polling);
+    memcpy(state->thr_polling.fds, state->polling.fds,
+           n * sizeof(struct pollfd));
+    memcpy(state->thr_polling.handlers, state->polling.handlers,
+           n * sizeof(poll_handler_t*));
+}
+
+static int proc_kick_handler (zbar_processor_t *proc,
+                              int i)
+{
+    processor_state_t *state = proc->state;
+    zprintf(5, "kicking %d fds\n", state->polling.num);
+
+    unsigned junk[2];
+    int rc = read(state->kick_fds[0], junk, 2 * sizeof(unsigned));
+
+    assert(proc->threaded);
+    _zbar_mutex_lock(&proc->mutex);
+    proc_cache_polling(proc->state);
+    _zbar_mutex_unlock(&proc->mutex);
+    return(rc);
+}
+
+static inline int proc_poll_inputs (zbar_processor_t *proc,
+                                    int timeout)
+{
+    processor_state_t *state = proc->state;
+    if(state->pre_poll_handler)
+        state->pre_poll_handler(proc, -1);
+
+    poll_desc_t *p = &state->thr_polling;
+    assert(p->num);
+    int rc = poll(p->fds, p->num, timeout);
+    if(rc <= 0)
+        /* FIXME detect and handle fatal errors (somehow) */
+        return(rc);
+    int i;
+    for(i = p->num - 1; i >= 0; i--)
+        if(p->fds[i].revents) {
+            if(p->handlers[i])
+                p->handlers[i](proc, i);
+            p->fds[i].revents = 0; /* debug */
+            rc--;
+        }
+    assert(!rc);
+    return(1);
+}
+
+int _zbar_processor_input_wait (zbar_processor_t *proc,
+                                zbar_event_t *event,
+                                int timeout)
+{
+    processor_state_t *state = proc->state;
+    if(state->thr_polling.num) {
+        if(event) {
+            _zbar_mutex_lock(&proc->mutex);
+            event->pollfd = state->kick_fds[1];
+            _zbar_mutex_unlock(&proc->mutex);
+        }
+        return(proc_poll_inputs(proc, timeout));
+    }
+    else if(timeout)
+        return(proc_sleep(timeout));
+    return(-1);
+}
+
+int _zbar_processor_init (zbar_processor_t *proc)
+{
+    processor_state_t *state = proc->state =
+        calloc(1, sizeof(processor_state_t));
+    state->kick_fds[0] = state->kick_fds[1] = -1;
+
+    if(proc->threaded) {
+        /* FIXME check errors */
+        if(pipe(state->kick_fds))
+            return(err_capture(proc, SEV_FATAL, ZBAR_ERR_SYSTEM, __func__,
+                               "failed to open pipe"));
+        add_poll(proc, state->kick_fds[0], proc_kick_handler);
+        proc_cache_polling(proc->state);
+    }
+    return(0);
+}
+
+int _zbar_processor_cleanup (zbar_processor_t *proc)
+{
+    processor_state_t *state = proc->state;
+    if(proc->threaded) {
+        close(state->kick_fds[0]);
+        close(state->kick_fds[1]);
+        state->kick_fds[0] = state->kick_fds[1] = -1;
+    }
+    if(state->polling.fds) {
+        free(state->polling.fds);
+        state->polling.fds = NULL;
+        if(!proc->threaded)
+            state->thr_polling.fds = NULL;
+    }
+    if(state->polling.handlers) {
+        free(state->polling.handlers);
+        state->polling.handlers = NULL;
+        if(!proc->threaded)
+            state->thr_polling.handlers = NULL;
+    }
+    if(state->thr_polling.fds) {
+        free(state->thr_polling.fds);
+        state->thr_polling.fds = NULL;
+    }
+    if(state->thr_polling.handlers) {
+        free(state->thr_polling.handlers);
+        state->thr_polling.handlers = NULL;
+    }
+    free(proc->state);
+    proc->state = NULL;
+    return(0);
+}
+
+int _zbar_processor_enable (zbar_processor_t *proc)
+{
+    int vid_fd = zbar_video_get_fd(proc->video);
+    if(vid_fd < 0)
+        return(0);
+
+    if(proc->streaming)
+        add_poll(proc, vid_fd, proc_video_handler);
+    else
+        remove_poll(proc, vid_fd);
+    /* FIXME failure recovery? */
+    return(0);
+}

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/processor/posix.h

@@ -0,0 +1,138 @@
+/*------------------------------------------------------------------------
+ *  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+ *
+ *  This file is part of the ZBar Bar Code Reader.
+ *
+ *  The ZBar Bar Code Reader is free software; you can redistribute it
+ *  and/or modify it under the terms of the GNU Lesser Public License as
+ *  published by the Free Software Foundation; either version 2.1 of
+ *  the License, or (at your option) any later version.
+ *
+ *  The ZBar Bar Code Reader 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 Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser Public License
+ *  along with the ZBar Bar Code Reader; if not, write to the Free
+ *  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *  Boston, MA  02110-1301  USA
+ *
+ *  http://sourceforge.net/projects/zbar
+ *------------------------------------------------------------------------*/
+#ifndef _PROCESSOR_POSIX_H_
+#define _PROCESSOR_POSIX_H_
+
+#include "processor.h"
+
+#ifdef HAVE_POLL_H
+# include <poll.h>
+#endif
+
+#ifdef HAVE_POLL_H
+typedef int (poll_handler_t)(zbar_processor_t*, int);
+
+/* poll information */
+typedef struct poll_desc_s {
+    int num;                            /* number of descriptors */
+    struct pollfd *fds;                 /* poll descriptors */
+    poll_handler_t **handlers;          /* poll handlers */
+} poll_desc_t;
+#endif
+
+struct processor_state_s {
+#ifdef HAVE_POLL_H
+    poll_desc_t polling;                /* polling registration */
+    poll_desc_t thr_polling;            /* thread copy */
+#endif
+    int kick_fds[2];                    /* poll kicker */
+    poll_handler_t *pre_poll_handler;   /* special case */
+};
+
+
+#ifdef HAVE_POLL_H
+static inline int alloc_polls (volatile poll_desc_t *p)
+{
+    p->fds = realloc(p->fds, p->num * sizeof(struct pollfd));
+    p->handlers = realloc(p->handlers, p->num * sizeof(poll_handler_t*));
+    /* FIXME should check for ENOMEM */
+    return(0);
+}
+
+static inline int add_poll (zbar_processor_t *proc,
+                            int fd,
+                            poll_handler_t *handler)
+{
+    processor_state_t *state = proc->state;
+
+    _zbar_mutex_lock(&proc->mutex);
+
+    poll_desc_t *polling = &state->polling;
+    unsigned i = polling->num++;
+    zprintf(5, "[%d] fd=%d handler=%p\n", i, fd, handler);
+    if(!alloc_polls(polling)) {
+        memset(&polling->fds[i], 0, sizeof(struct pollfd));
+        polling->fds[i].fd = fd;
+        polling->fds[i].events = POLLIN;
+        polling->handlers[i] = handler;
+    }
+    else
+        i = -1;
+
+    _zbar_mutex_unlock(&proc->mutex);
+
+    if(proc->input_thread.started) {
+        assert(state->kick_fds[1] >= 0);
+        if(write(state->kick_fds[1], &i /* unused */, sizeof(unsigned)) < 0)
+            return(-1);
+    }
+    else if(!proc->threaded) {
+        state->thr_polling.num = polling->num;
+        state->thr_polling.fds = polling->fds;
+        state->thr_polling.handlers = polling->handlers;
+    }
+    return(i);
+}
+
+static inline int remove_poll (zbar_processor_t *proc,
+                               int fd)
+{
+    processor_state_t *state = proc->state;
+
+    _zbar_mutex_lock(&proc->mutex);
+
+    poll_desc_t *polling = &state->polling;
+    int i;
+    for(i = polling->num - 1; i >= 0; i--)
+        if(polling->fds[i].fd == fd)
+            break;
+    zprintf(5, "[%d] fd=%d n=%d\n", i, fd, polling->num);
+
+    if(i >= 0) {
+        if(i + 1 < polling->num) {
+            int n = polling->num - i - 1;
+            memmove(&polling->fds[i], &polling->fds[i + 1],
+                    n * sizeof(struct pollfd));
+            memmove(&polling->handlers[i], &polling->handlers[i + 1],
+                    n * sizeof(poll_handler_t));
+        }
+        polling->num--;
+        i = alloc_polls(polling);
+    }
+
+    _zbar_mutex_unlock(&proc->mutex);
+
+    if(proc->input_thread.started) {
+        if(write(state->kick_fds[1], &i /* unused */, sizeof(unsigned)) < 0)
+            return(-1);
+    }
+    else if(!proc->threaded) {
+        state->thr_polling.num = polling->num;
+        state->thr_polling.fds = polling->fds;
+        state->thr_polling.handlers = polling->handlers;
+    }
+    return(i);
+}
+#endif
+
+#endif