rhodes 3.0.2 → 3.1.0.beta.1

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

@@ -1,126 +0,0 @@
-/*------------------------------------------------------------------------
- *  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_H_
-#define _PROCESSOR_H_
-
-#include "../../config.h"
-#ifdef HAVE_INTTYPES_H
-# include "../../inttypes.h"
-#endif
-//#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "../include/zbar.h"
-#include "error.h"
-#include "thread.h"
-#include "event.h"
-
-/* max time to wait for input before looking for the next frame.
- * only used in unthreaded mode with blocking (non-pollable) video.
- * NB subject to precision of whatever timer is in use
- */
-#define MAX_INPUT_BLOCK 15/*ms*/
-
-/* platform specific state wrapper */
-typedef struct processor_state_s processor_state_t;
-
-/* specific notification tracking */
-typedef struct proc_waiter_s {
-    struct proc_waiter_s *next;
-    zbar_event_t notify;
-    zbar_thread_id_t requester;
-    unsigned events;
-} proc_waiter_t;
-
-/* high-level API events */
-#define EVENT_INPUT     0x01            /* user input */
-#define EVENT_OUTPUT    0x02            /* decoded output data available */
-#define EVENT_CANCELED  0x80            /* cancelation flag */
-#define EVENTS_PENDING  (EVENT_INPUT | EVENT_OUTPUT)
-
-struct zbar_processor_s {
-    errinfo_t err;                      /* error reporting */
-    const void *userdata;               /* application data */
-
-    zbar_video_t *video;                /* input video device abstraction */
-    zbar_window_t *window;              /* output window abstraction */
-    zbar_image_scanner_t *scanner;      /* barcode scanner */
-
-    zbar_image_data_handler_t *handler; /* application data handler */
-
-    unsigned req_width, req_height;     /* application requested video size */
-    int req_intf, req_iomode;           /* application requested interface */
-    uint32_t force_input;               /* force input format (debug) */
-    uint32_t force_output;              /* force format conversion (debug) */
-
-    int input;                          /* user input status */
-
-    /* state flags */
-    int threaded;
-    int visible;                        /* output window mapped to display */
-    int streaming;                      /* video enabled */
-    int dumping;                        /* debug image dump */
-
-    void *display;                      /* X display connection */
-    unsigned long xwin;                 /* toplevel window */
-
-    zbar_thread_t input_thread;         /* video input handler */
-    zbar_thread_t video_thread;         /* window event handler */
-
-    const zbar_symbol_set_t *syms;      /* previous decode results */
-
-    zbar_mutex_t mutex;                 /* shared data mutex */
-
-    /* API serialization lock */
-    int lock_level;
-    zbar_thread_id_t lock_owner;
-    proc_waiter_t *wait_head, *wait_tail, *wait_next;
-    proc_waiter_t *free_waiter;
-
-    processor_state_t *state;
-};
-
-/* processor lock API */
-extern int _zbar_processor_lock(zbar_processor_t*);
-extern int _zbar_processor_unlock(zbar_processor_t*, int);
-extern void _zbar_processor_notify(zbar_processor_t*, unsigned);
-extern int _zbar_processor_wait(zbar_processor_t*, unsigned, zbar_timer_t*);
-
-/* platform API */
-extern int _zbar_processor_init(zbar_processor_t*);
-extern int _zbar_processor_cleanup(zbar_processor_t*);
-extern int _zbar_processor_input_wait(zbar_processor_t*, zbar_event_t*, int);
-extern int _zbar_processor_enable(zbar_processor_t*);
-
-extern int _zbar_process_image(zbar_processor_t*, zbar_image_t*);
-extern int _zbar_processor_handle_input(zbar_processor_t*, int);
-
-/* windowing platform API */
-extern int _zbar_processor_open(zbar_processor_t*, char*, unsigned, unsigned);
-extern int _zbar_processor_close(zbar_processor_t*);
-extern int _zbar_processor_set_visible(zbar_processor_t*, int);
-extern int _zbar_processor_set_size(zbar_processor_t*, unsigned, unsigned);
-extern int _zbar_processor_invalidate(zbar_processor_t*);
-
-#endif

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

@@ -1,227 +0,0 @@
-/*------------------------------------------------------------------------
- *  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 <assert.h>
-
-/* the processor api lock is a recursive mutex with added capabilities
- * to completely drop all lock levels before blocking and atomically
- * unblock a waiting set.  the lock is implemented using a variation
- * of the "specific notification pattern" [cargill], which makes it
- * easy to provide these features across platforms with consistent,
- * predictable semantics.  probably overkill, but additional overhead
- * associated with this mechanism should fall in the noise, as locks
- * are only exchanged O(frame/image)
- *
- * [cargill]
- * http://www.profcon.com/profcon/cargill/jgf/9809/SpecificNotification.html
- */
-
-static inline proc_waiter_t *proc_waiter_queue (zbar_processor_t *proc)
-{
-    proc_waiter_t *waiter = proc->free_waiter;
-    if(waiter) {
-        proc->free_waiter = waiter->next;
-        waiter->events = 0;
-    }
-    else {
-        waiter = calloc(1, sizeof(proc_waiter_t));
-        _zbar_event_init(&waiter->notify);
-    }
-
-    waiter->next = NULL;
-    waiter->requester = _zbar_thread_self();
-
-    if(proc->wait_head)
-        proc->wait_tail->next = waiter;
-    else
-        proc->wait_head = waiter;
-    proc->wait_tail = waiter;
-    return(waiter);
-}
-
-static inline proc_waiter_t *proc_waiter_dequeue (zbar_processor_t *proc)
-{
-    proc_waiter_t *prev = proc->wait_next, *waiter;
-    if(prev)
-        waiter = prev->next;
-    else
-        waiter = proc->wait_head;
-    while(waiter && (waiter->events & EVENTS_PENDING)) {
-        prev = waiter;
-        proc->wait_next = waiter;
-        waiter = waiter->next;
-    }
-
-    if(waiter) {
-        if(prev)
-            prev->next = waiter->next;
-        else
-            proc->wait_head = waiter->next;
-        if(!waiter->next)
-            proc->wait_tail = prev;
-        waiter->next = NULL;
-
-        proc->lock_level = 1;
-        proc->lock_owner = waiter->requester;
-    }
-    return(waiter);
-}
-
-static inline void proc_waiter_release (zbar_processor_t *proc,
-                                        proc_waiter_t *waiter)
-{
-    if(waiter) {
-        waiter->next = proc->free_waiter;
-        proc->free_waiter = waiter;
-    }
-}
-
-int _zbar_processor_lock (zbar_processor_t *proc)
-{
-    if(!proc->lock_level) {
-        proc->lock_owner = _zbar_thread_self();
-        proc->lock_level = 1;
-        return(0);
-    }
-
-    if(_zbar_thread_is_self(proc->lock_owner)) {
-        proc->lock_level++;
-        return(0);
-    }
-
-    proc_waiter_t *waiter = proc_waiter_queue(proc);
-    _zbar_event_wait(&waiter->notify, &proc->mutex, NULL);
-
-    assert(proc->lock_level == 1);
-    assert(_zbar_thread_is_self(proc->lock_owner));
-
-    proc_waiter_release(proc, waiter);
-    return(0);
-}
-
-int _zbar_processor_unlock (zbar_processor_t *proc,
-                            int all)
-{
-    assert(proc->lock_level > 0);
-    assert(_zbar_thread_is_self(proc->lock_owner));
-
-    if(all)
-        proc->lock_level = 0;
-    else
-        proc->lock_level--;
-
-    if(!proc->lock_level) {
-        proc_waiter_t *waiter = proc_waiter_dequeue(proc);
-        if(waiter)
-            _zbar_event_trigger(&waiter->notify);
-    }
-    return(0);
-}
-
-void _zbar_processor_notify (zbar_processor_t *proc,
-                             unsigned events)
-{
-    proc->wait_next = NULL;
-    proc_waiter_t *waiter;
-    for(waiter = proc->wait_head; waiter; waiter = waiter->next)
-        waiter->events = ((waiter->events & ~events) |
-                          (events & EVENT_CANCELED));
-
-    if(!proc->lock_level) {
-        waiter = proc_waiter_dequeue(proc);
-        if(waiter)
-            _zbar_event_trigger(&waiter->notify);
-    }
-}
-
-static inline int proc_wait_unthreaded (zbar_processor_t *proc,
-                                        proc_waiter_t *waiter,
-                                        zbar_timer_t *timeout)
-{
-    int blocking = proc->streaming && zbar_video_get_fd(proc->video) < 0;
-    _zbar_mutex_unlock(&proc->mutex);
-
-    int rc = 1;
-    while(rc > 0 && (waiter->events & EVENTS_PENDING)) {
-        /* FIXME lax w/the locking (though shouldn't matter...) */
-        if(blocking) {
-            zbar_image_t *img = zbar_video_next_image(proc->video);
-            if(!img) {
-                rc = -1;
-                break;
-            }
-
-            /* FIXME reacquire API lock! (refactor w/video thread?) */
-            _zbar_mutex_lock(&proc->mutex);
-            _zbar_process_image(proc, img);
-            zbar_image_destroy(img);
-            _zbar_mutex_unlock(&proc->mutex);
-        }
-        int reltime = _zbar_timer_check(timeout);
-        if(blocking && (reltime < 0 || reltime > MAX_INPUT_BLOCK))
-            reltime = MAX_INPUT_BLOCK;
-        rc = _zbar_processor_input_wait(proc, NULL, reltime);
-    }
-    _zbar_mutex_lock(&proc->mutex);
-    return(rc);
-}
-
-int _zbar_processor_wait (zbar_processor_t *proc,
-                          unsigned events,
-                          zbar_timer_t *timeout)
-{
-    _zbar_mutex_lock(&proc->mutex);
-    int save_level = proc->lock_level;
-    proc_waiter_t *waiter = proc_waiter_queue(proc);
-    waiter->events = events & EVENTS_PENDING;
-
-    _zbar_processor_unlock(proc, 1);
-    int rc;
-    if(proc->threaded)
-        rc = _zbar_event_wait(&waiter->notify, &proc->mutex, timeout);
-    else
-        rc = proc_wait_unthreaded(proc, waiter, timeout);
-
-    if(rc <= 0 || !proc->threaded) {
-        /* reacquire api lock */
-        waiter->events &= EVENT_CANCELED;
-        proc->wait_next = NULL;
-        if(!proc->lock_level) {
-            proc_waiter_t *w = proc_waiter_dequeue(proc);
-            assert(w == waiter);
-        }
-        else
-            _zbar_event_wait(&waiter->notify, &proc->mutex, NULL);
-    }
-    if(rc > 0 && (waiter->events & EVENT_CANCELED))
-        rc = -1;
-
-    assert(proc->lock_level == 1);
-    assert(_zbar_thread_is_self(proc->lock_owner));
-
-    proc->lock_level = save_level;
-    proc_waiter_release(proc, waiter);
-    _zbar_mutex_unlock(&proc->mutex);
-    return(rc);
-}

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

@@ -1,62 +0,0 @@
-/*------------------------------------------------------------------------
- *  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

@@ -1,337 +0,0 @@
-/*------------------------------------------------------------------------
- *  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);
-}