rhodes 3.0.2 → 3.1.0.beta.1

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

@@ -1,38 +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 _IMG_SCANNER_H_
-#define _IMG_SCANNER_H_
-
-#include "../include/zbar.h"
-
-/* internal image scanner APIs for 2D readers */
-
-extern zbar_symbol_t *_zbar_image_scanner_alloc_sym(zbar_image_scanner_t*,
-                                                    zbar_symbol_type_t,
-                                                    int);
-extern void _zbar_image_scanner_add_sym(zbar_image_scanner_t*,
-                                        zbar_symbol_t*);
-extern void _zbar_image_scanner_recycle_syms(zbar_image_scanner_t*,
-                                             zbar_symbol_t*);
-
-#endif

data/lib/extensions/barcode/ext/barcode/shared/zbar/zbar/zbar/jpeg.c

@@ -1,241 +0,0 @@
-/*------------------------------------------------------------------------
- *  Copyright 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 <stdio.h>
-#include <jpeglib.h>
-#include <jerror.h>
-#include <setjmp.h>
-#include <assert.h> /* FIXME tmp debug */
-
-#undef HAVE_STDLIB_H
-#include <zbar.h>
-#include "image.h"
-#include "video.h"
-
-#define HAVE_LONGJMP
-#ifdef HAVE_LONGJMP
-
-typedef struct errenv_s {
-    struct jpeg_error_mgr err;
-    int valid;
-    jmp_buf env;
-} errenv_t;
-
-void zbar_jpeg_error (j_common_ptr cinfo)
-{
-    errenv_t *jerr = (errenv_t*)cinfo->err;
-    assert(jerr->valid);
-    jerr->valid = 0;
-    longjmp(jerr->env, 1);
-    assert(0);
-}
-
-#endif
-
-typedef struct zbar_src_mgr_s {
-    struct jpeg_source_mgr src;
-    const zbar_image_t *img;
-} zbar_src_mgr_t;
-
-static const JOCTET fake_eoi[2] = { 0xff, JPEG_EOI };
-
-void init_source (j_decompress_ptr cinfo)
-{
-    /* buffer/length refer to compressed data */
-    /* FIXME find img */
-    const zbar_image_t *img = ((zbar_src_mgr_t*)cinfo->src)->img;
-    cinfo->src->next_input_byte = img->data;
-    cinfo->src->bytes_in_buffer = img->datalen;
-}
-
-int fill_input_buffer (j_decompress_ptr cinfo)
-{
-    /* buffer underrun error case */
-    cinfo->src->next_input_byte = fake_eoi;
-    cinfo->src->bytes_in_buffer = 2;
-    return(1);
-}
-
-void skip_input_data (j_decompress_ptr cinfo,
-                      long num_bytes)
-{
-    cinfo->src->next_input_byte = NULL;
-    cinfo->src->bytes_in_buffer = 0;
-}
-
-void term_source (j_decompress_ptr cinfo)
-{
-    /* nothing todo */
-}
-
-struct jpeg_decompress_struct * _zbar_jpeg_decomp_create (void)
-{
-    j_decompress_ptr cinfo = calloc(1, sizeof(struct jpeg_decompress_struct));
-    if(!cinfo)
-        return(NULL);
-
-    errenv_t *jerr = calloc(1, sizeof(errenv_t));
-    if(!jerr) {
-        free(cinfo);
-        return(NULL);
-    }
-
-    cinfo->err = jpeg_std_error(&jerr->err);
-    jerr->err.error_exit = zbar_jpeg_error;
-
-    jerr->valid = 1;
-    if(setjmp(jerr->env)) {
-        jpeg_destroy_decompress(cinfo);
-
-        /* FIXME TBD save error to errinfo_t */
-        (*cinfo->err->output_message)((j_common_ptr)cinfo);
-
-        free(jerr);
-        free(cinfo);
-        return(NULL);
-    }
-
-    jpeg_create_decompress(cinfo);
-
-    jerr->valid = 0;
-    return(cinfo);
-}
-
-void _zbar_jpeg_decomp_destroy (struct jpeg_decompress_struct *cinfo)
-{
-    if(cinfo->err) {
-        free(cinfo->err);
-        cinfo->err = NULL;
-    }
-    if(cinfo->src) {
-        free(cinfo->src);
-        cinfo->src = NULL;
-    }
-    /* FIXME can this error? */
-    jpeg_destroy_decompress(cinfo);
-    free(cinfo);
-}
-
-/* invoke libjpeg to decompress JPEG format to luminance plane */
-void _zbar_convert_jpeg_to_y (zbar_image_t *dst,
-                              const zbar_format_def_t *dstfmt,
-                              const zbar_image_t *src,
-                              const zbar_format_def_t *srcfmt)
-{
-    /* create decompressor, or use cached video stream decompressor */
-    errenv_t *jerr = NULL;
-    j_decompress_ptr cinfo;
-    if(!src->src)
-        cinfo = _zbar_jpeg_decomp_create();
-    else {
-        cinfo = src->src->jpeg;
-        assert(cinfo);
-    }
-    if(!cinfo)
-        goto error;
-
-    jerr = (errenv_t*)cinfo->err;
-    jerr->valid = 1;
-    if(setjmp(jerr->env)) {
-        /* FIXME TBD save error to src->src->err */
-        (*cinfo->err->output_message)((j_common_ptr)cinfo);
-        if(dst->data) {
-            free((void*)dst->data);
-            dst->data = NULL;
-        }
-        dst->datalen = 0;
-        goto error;
-    }
-
-    /* setup input image */
-    if(!cinfo->src) {
-        cinfo->src = calloc(1, sizeof(zbar_src_mgr_t));
-        cinfo->src->init_source = init_source;
-        cinfo->src->fill_input_buffer = fill_input_buffer;
-        cinfo->src->skip_input_data = skip_input_data;
-        cinfo->src->resync_to_restart = jpeg_resync_to_restart;
-        cinfo->src->term_source = term_source;
-    }
-    cinfo->src->next_input_byte = NULL;
-    cinfo->src->bytes_in_buffer = 0;
-    ((zbar_src_mgr_t*)cinfo->src)->img = src;
-
-    int rc = jpeg_read_header(cinfo, TRUE);
-    zprintf(30, "header: %s\n", (rc == 2) ? "tables-only" : "normal");
-
-    /* supporting color with jpeg became...complicated,
-     * so we skip that for now
-     */
-    cinfo->out_color_space = JCS_GRAYSCALE;
-
-    /* FIXME set scaling based on dst->{width,height}
-     * then pass bigger buffer...
-     */
-
-    jpeg_start_decompress(cinfo);
-
-    /* adjust dst image parameters to match(?) decompressor */
-    if(dst->width < cinfo->output_width) {
-        dst->width = cinfo->output_width;
-        if(dst->crop_x + dst->crop_w > dst->width)
-            dst->crop_w = dst->width - dst->crop_x;
-    }
-    if(dst->height < cinfo->output_height) {
-        dst->height = cinfo->output_height;
-        if(dst->crop_y + dst->crop_h > dst->height)
-            dst->crop_h = dst->height - dst->crop_y;
-    }
-    unsigned long datalen = (cinfo->output_width *
-                             cinfo->output_height *
-                             cinfo->out_color_components);
-
-    zprintf(24, "dst=%dx%d %lx src=%dx%d %lx dct=%x\n",
-            dst->width, dst->height, dst->datalen,
-            src->width, src->height, src->datalen, cinfo->dct_method);
-    if(!dst->data) {
-        dst->datalen = datalen;
-        dst->data = malloc(dst->datalen);
-        dst->cleanup = zbar_image_free_data;
-    }
-    else
-        assert(datalen <= dst->datalen);
-    if(!dst->data) return;
-
-    unsigned bpl = dst->width * cinfo->output_components;
-    JSAMPROW buf = (void*)dst->data;
-    JSAMPARRAY line = &buf;
-    for(; cinfo->output_scanline < cinfo->output_height; buf += bpl) {
-        jpeg_read_scanlines(cinfo, line, 1);
-        /* FIXME pad out to dst->width */
-    }
-
-    /* FIXME always do this? */
-    jpeg_finish_decompress(cinfo);
-
- error:
-    if(jerr)
-        jerr->valid = 0;
-    if(!src->src && cinfo)
-        /* cleanup only if we allocated locally */
-        _zbar_jpeg_decomp_destroy(cinfo);
-}

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

@@ -1,160 +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 _ZBAR_MUTEX_H_
-#define _ZBAR_MUTEX_H_
-
-#include "../../config.h"
-
-/* simple platform mutex abstraction
- */
-
-#if defined(_WIN32)
-
-# include <windows.h>
-
-# define DEBUG_LOCKS
-# ifdef DEBUG_LOCKS
-
-typedef struct zbar_mutex_s {
-    int count;
-    CRITICAL_SECTION mutex;
-} zbar_mutex_t;
-
-static inline int _zbar_mutex_init (zbar_mutex_t *lock)
-{
-    lock->count = 1;
-    InitializeCriticalSection(&lock->mutex);
-    return(0);
-}
-
-static inline void _zbar_mutex_destroy (zbar_mutex_t *lock)
-{
-    DeleteCriticalSection(&lock->mutex);
-}
-
-static inline int _zbar_mutex_lock (zbar_mutex_t *lock)
-{
-    EnterCriticalSection(&lock->mutex);
-    if(lock->count++ < 1)
-        assert(0);
-    return(0);
-}
-
-static inline int _zbar_mutex_unlock (zbar_mutex_t *lock)
-{
-    if(lock->count-- <= 1)
-        assert(0);
-    LeaveCriticalSection(&lock->mutex);
-    return(0);
-}
-
-# else
-
-typedef CRITICAL_SECTION zbar_mutex_t;
-
-static inline int _zbar_mutex_init (zbar_mutex_t *lock)
-{
-    InitializeCriticalSection(lock);
-    return(0);
-}
-
-static inline void _zbar_mutex_destroy (zbar_mutex_t *lock)
-{
-    DeleteCriticalSection(lock);
-}
-
-static inline int _zbar_mutex_lock (zbar_mutex_t *lock)
-{
-    EnterCriticalSection(lock);
-    return(0);
-}
-
-static inline int _zbar_mutex_unlock (zbar_mutex_t *lock)
-{
-    LeaveCriticalSection(lock);
-    return(0);
-}
-
-# endif
-
-
-#elif defined(HAVE_LIBPTHREAD)
-
-# include <pthread.h>
-
-typedef pthread_mutex_t zbar_mutex_t;
-
-static inline int _zbar_mutex_init (zbar_mutex_t *lock)
-{
-# ifdef DEBUG_LOCKS
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
-    int rc = pthread_mutex_init(lock, &attr);
-    pthread_mutexattr_destroy(&attr);
-    return(rc);
-# else
-    return(pthread_mutex_init(lock, NULL));
-# endif
-}
-
-static inline void _zbar_mutex_destroy (zbar_mutex_t *lock)
-{
-    pthread_mutex_destroy(lock);
-}
-
-static inline int _zbar_mutex_lock (zbar_mutex_t *lock)
-{
-    int rc = pthread_mutex_lock(lock);
-# ifdef DEBUG_LOCKS
-    assert(!rc);
-# endif
-    /* FIXME save system code */
-    /*rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_LOCKING, __func__,
-                       "unable to lock processor");*/
-    return(rc);
-}
-
-static inline int _zbar_mutex_unlock (zbar_mutex_t *lock)
-{
-    int rc = pthread_mutex_unlock(lock);
-# ifdef DEBUG_LOCKS
-    assert(!rc);
-# endif
-    /* FIXME save system code */
-    return(rc);
-}
-
-
-#else
-
-typedef int zbar_mutex_t[0];
-
-#define _zbar_mutex_init(l) -1
-#define _zbar_mutex_destroy(l)
-#define _zbar_mutex_lock(l) 0
-#define _zbar_mutex_unlock(l) 0
-
-#endif
-
-#endif

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

@@ -1,700 +0,0 @@
-/*------------------------------------------------------------------------
- *  Copyright 2007-2010 (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 "window.h"
-#include "image.h"
-
-static inline int proc_enter (zbar_processor_t *proc)
-{
-    _zbar_mutex_lock(&proc->mutex);
-    return(_zbar_processor_lock(proc));
-}
-
-static inline int proc_leave (zbar_processor_t *proc)
-{
-    int rc = _zbar_processor_unlock(proc, 0);
-    _zbar_mutex_unlock(&proc->mutex);
-    return(rc);
-}
-
-static inline int proc_open (zbar_processor_t *proc)
-{
-    /* arbitrary default */
-    int width = 640, height = 480;
-    if(proc->video) {
-        width = zbar_video_get_width(proc->video);
-        height = zbar_video_get_height(proc->video);
-    }
-    return(_zbar_processor_open(proc, "zbar barcode reader", width, height));
-}
-
-/* API lock is already held */
-int _zbar_process_image (zbar_processor_t *proc,
-                         zbar_image_t *img)
-{
-    uint32_t force_fmt = proc->force_output;
-	int rc;
-
-	if(img) {
-		uint32_t format;
-		zbar_image_t *tmp;
-		int nsyms;
-
-        if(proc->dumping) {
-            zbar_image_write(proc->window->image, "zbar");
-            proc->dumping = 0;
-        }
-
-			
-		format = zbar_image_get_format(img);
-		
-        zprintf(16, "processing: %.4s(%08" PRIx32 ") %dx%d @%p\n",
-                (char*)&format, format,
-                zbar_image_get_width(img), zbar_image_get_height(img),
-                zbar_image_get_data(img));
-
-        /* FIXME locking all other interfaces while processing is conservative
-         * but easier for now and we don't expect this to take long...
-         */
-        tmp = zbar_image_convert(img, fourcc('Y','8','0','0'));
-        if(!tmp)
-            goto error;
-
-        if(proc->syms) {
-            zbar_symbol_set_ref(proc->syms, -1);
-            proc->syms = NULL;
-        }
-        zbar_image_scanner_recycle_image(proc->scanner, img);
-        nsyms = zbar_scan_image(proc->scanner, tmp);
-        _zbar_image_swap_symbols(img, tmp);
-
-        zbar_image_destroy(tmp);
-        tmp = NULL;
-        if(nsyms < 0)
-            goto error;
-
-        proc->syms = zbar_image_scanner_get_results(proc->scanner);
-        if(proc->syms)
-            zbar_symbol_set_ref(proc->syms, 1);
-
-        if(_zbar_verbosity >= 8) {
-            const zbar_symbol_t *sym = zbar_image_first_symbol(img);
-            while(sym) {
-                zbar_symbol_type_t type = zbar_symbol_get_type(sym);
-                int count = zbar_symbol_get_count(sym);
-                zprintf(8, "%s%s: %s (%d pts) (dir=%d) (q=%d) (%s)\n",
-                        zbar_get_symbol_name(type),
-                        zbar_get_addon_name(type),
-                        zbar_symbol_get_data(sym),
-                        zbar_symbol_get_loc_size(sym),
-                        zbar_symbol_get_orientation(sym),
-                        zbar_symbol_get_quality(sym),
-                        (count < 0) ? "uncertain" :
-                        (count > 0) ? "duplicate" : "new");
-                sym = zbar_symbol_next(sym);
-            }
-        }
-
-        if(nsyms) {
-            /* FIXME only call after filtering */
-            _zbar_mutex_lock(&proc->mutex);
-            _zbar_processor_notify(proc, EVENT_OUTPUT);
-            _zbar_mutex_unlock(&proc->mutex);
-            if(proc->handler)
-                proc->handler(img, proc->userdata);
-        }
-
-        if(force_fmt) {
-            zbar_symbol_set_t *syms = img->syms;
-            img = zbar_image_convert(img, force_fmt);
-            if(!img)
-                goto error;
-            img->syms = syms;
-            zbar_symbol_set_ref(syms, 1);
-        }
-    }
-
-    /* display to window if enabled */
-    rc = 0;
-    if(proc->window) {
-        if((rc = zbar_window_draw(proc->window, img)))
-            err_copy(proc, proc->window);
-        _zbar_processor_invalidate(proc);
-    }
-
-    if(force_fmt && img)
-        zbar_image_destroy(img);
-    return(rc);
-
-error:
-    return(err_capture(proc, SEV_ERROR, ZBAR_ERR_UNSUPPORTED,
-                       __func__, "unknown image format"));
-}
-
-int _zbar_processor_handle_input (zbar_processor_t *proc,
-                                  int input)
-{
-    int event = EVENT_INPUT;
-    switch(input) {
-    case -1:
-        event |= EVENT_CANCELED;
-        _zbar_processor_set_visible(proc, 0);
-        err_capture(proc, SEV_WARNING, ZBAR_ERR_CLOSED, __func__,
-                    "user closed display window");
-        break;
-
-    case 'd':
-        proc->dumping = 1;
-        return(0);
-
-    case '+':
-    case '=':
-        if(proc->window) {
-            int ovl = zbar_window_get_overlay(proc->window);
-            zbar_window_set_overlay(proc->window, ovl + 1);
-        }
-        break;
-
-    case '-':
-        if(proc->window) {
-            int ovl = zbar_window_get_overlay(proc->window);
-            zbar_window_set_overlay(proc->window, ovl - 1);
-        }
-        break;
-    }
-
-    _zbar_mutex_lock(&proc->mutex);
-    proc->input = input;
-    if(input == -1 && proc->visible && proc->streaming)
-        /* also cancel outstanding output waiters */
-        event |= EVENT_OUTPUT;
-    _zbar_processor_notify(proc, event);
-    _zbar_mutex_unlock(&proc->mutex);
-    return(input);
-}
-
-#ifdef ZTHREAD
-
-static ZTHREAD proc_video_thread (void *arg)
-{
-    zbar_processor_t *proc = arg;
-    zbar_thread_t *thread = &proc->video_thread;
-
-    _zbar_mutex_lock(&proc->mutex);
-    _zbar_thread_init(thread);
-    zprintf(4, "spawned video thread\n");
-
-    while(thread->started) {
-        /* wait for video stream to be active */
-        while(thread->started && !proc->streaming)
-            _zbar_event_wait(&thread->notify, &proc->mutex, NULL);
-        if(!thread->started)
-            break;
-
-        /* blocking capture image from video */
-        _zbar_mutex_unlock(&proc->mutex);
-        zbar_image_t *img = zbar_video_next_image(proc->video);
-        _zbar_mutex_lock(&proc->mutex);
-
-        if(!img && !proc->streaming)
-            continue;
-        else if(!img)
-            /* FIXME could abort streaming and keep running? */
-            break;
-
-        /* acquire API lock */
-        _zbar_processor_lock(proc);
-        _zbar_mutex_unlock(&proc->mutex);
-
-        if(thread->started && proc->streaming)
-            _zbar_process_image(proc, img);
-
-        zbar_image_destroy(img);
-
-        _zbar_mutex_lock(&proc->mutex);
-        /* release API lock */
-        _zbar_processor_unlock(proc, 0);
-    }
-
-    thread->running = 0;
-    _zbar_event_trigger(&thread->activity);
-    _zbar_mutex_unlock(&proc->mutex);
-    return(0);
-}
-
-static ZTHREAD proc_input_thread (void *arg)
-{
-    zbar_processor_t *proc = arg;
-    zbar_thread_t *thread = &proc->input_thread;
-    if(proc->window && proc_open(proc))
-        goto done;
-
-    _zbar_mutex_lock(&proc->mutex);
-    thread->running = 1;
-    _zbar_event_trigger(&thread->activity);
-    zprintf(4, "spawned input thread\n");
-
-    int rc = 0;
-    while(thread->started && rc >= 0) {
-        _zbar_mutex_unlock(&proc->mutex);
-        rc = _zbar_processor_input_wait(proc, &thread->notify, -1);
-        _zbar_mutex_lock(&proc->mutex);
-    }
-
-    _zbar_mutex_unlock(&proc->mutex);
-    _zbar_processor_close(proc);
-    _zbar_mutex_lock(&proc->mutex);
-
- done:
-    thread->running = 0;
-    _zbar_event_trigger(&thread->activity);
-    _zbar_mutex_unlock(&proc->mutex);
-    return(0);
-}
-
-#endif
-
-zbar_processor_t *zbar_processor_create (int threaded)
-{
-    zbar_processor_t *proc = calloc(1, sizeof(zbar_processor_t));
-    if(!proc)
-        return(NULL);
-    err_init(&proc->err, ZBAR_MOD_PROCESSOR);
-
-    proc->scanner = zbar_image_scanner_create();
-    if(!proc->scanner) {
-        free(proc);
-        return(NULL);
-    }
-
-    proc->threaded = !_zbar_mutex_init(&proc->mutex) && threaded;
-    _zbar_processor_init(proc);
-    return(proc);
-}
-
-void zbar_processor_destroy (zbar_processor_t *proc)
-{
-	proc_waiter_t *w, *next;
-
-	zbar_processor_init(proc, NULL, 0);
-
-    if(proc->syms) {
-        zbar_symbol_set_ref(proc->syms, -1);
-        proc->syms = NULL;
-    }
-    if(proc->scanner) {
-        zbar_image_scanner_destroy(proc->scanner);
-        proc->scanner = NULL;
-    }
-
-    _zbar_mutex_destroy(&proc->mutex);
-    _zbar_processor_cleanup(proc);
-
-    assert(!proc->wait_head);
-    assert(!proc->wait_tail);
-    assert(!proc->wait_next);
-
-    for(w = proc->free_waiter; w; w = next) {
-        next = w->next;
-        _zbar_event_destroy(&w->notify);
-        free(w);
-    }
-
-    err_cleanup(&proc->err);
-    free(proc);
-}
-
-int zbar_processor_init (zbar_processor_t *proc,
-                         const char *dev,
-                         int enable_display)
-{
-	int rc;
-	int video_threaded;
-
-    if(proc->video)
-        zbar_processor_set_active(proc, 0);
-
-    if(proc->window && !proc->input_thread.started)
-        _zbar_processor_close(proc);
-
-    _zbar_mutex_lock(&proc->mutex);
-    _zbar_thread_stop(&proc->input_thread, &proc->mutex);
-    _zbar_thread_stop(&proc->video_thread, &proc->mutex);
-
-    _zbar_processor_lock(proc);
-    _zbar_mutex_unlock(&proc->mutex);
-
-    if(proc->window) {
-        zbar_window_destroy(proc->window);
-        proc->window = NULL;
-    }
-
-    rc = 0;
-    if(proc->video) {
-        zbar_video_destroy(proc->video);
-        proc->video = NULL;
-    }
-
-    if(!dev && !enable_display)
-        /* nothing to do */
-        goto done;
-
-    if(enable_display) {
-        proc->window = zbar_window_create();
-        if(!proc->window) {
-            rc = err_capture(proc, SEV_FATAL, ZBAR_ERR_NOMEM,
-                             __func__, "allocating window resources");
-            goto done;
-        }
-    }
-
-    if(dev) {
-
-        proc->video = zbar_video_create();
-        if(!proc->video) {
-            rc = err_capture(proc, SEV_FATAL, ZBAR_ERR_NOMEM,
-                             __func__, "allocating video resources");
-            goto done;
-        }
-        if(proc->req_width || proc->req_height)
-            zbar_video_request_size(proc->video,
-                                     proc->req_width, proc->req_height);
-        if(proc->req_intf)
-            zbar_video_request_interface(proc->video, proc->req_intf);
-        if((proc->req_iomode &&
-            zbar_video_request_iomode(proc->video, proc->req_iomode)) ||
-           zbar_video_open(proc->video, dev)) {
-            rc = err_copy(proc, proc->video);
-            goto done;
-        }
-    }
-
-    /* spawn blocking video thread */
-    video_threaded = (proc->threaded && proc->video &&
-                          zbar_video_get_fd(proc->video) < 0);
-    if(video_threaded &&
-       _zbar_thread_start(&proc->video_thread, proc_video_thread, proc,
-                          &proc->mutex)) {
-        rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_SYSTEM, __func__,
-                         "spawning video thread");
-        goto done;
-    }
-
-    /* spawn input monitor thread */
-    int input_threaded = (proc->threaded &&
-                          (proc->window ||
-                           (proc->video && !video_threaded)));
-    if(input_threaded &&
-       _zbar_thread_start(&proc->input_thread, proc_input_thread, proc,
-                          &proc->mutex)) {
-        rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_SYSTEM, __func__,
-                         "spawning input thread");
-        goto done;
-    }
-
-    if(proc->window && !input_threaded &&
-       (rc = proc_open(proc)))
-        goto done;
-
-    if(proc->video && proc->force_input) {
-        if(zbar_video_init(proc->video, proc->force_input))
-            rc = err_copy(proc, proc->video);
-    }
-    else if(proc->video) {
-        int retry = -1;
-        if(proc->window) {
-            retry = zbar_negotiate_format(proc->video, proc->window);
-            if(retry)
-                fprintf(stderr,
-                        "WARNING: no compatible input to output format\n"
-                        "...trying again with output disabled\n");
-        }
-        if(retry)
-            retry = zbar_negotiate_format(proc->video, NULL);
-
-        if(retry) {
-            zprintf(1, "ERROR: no compatible %s format\n",
-                    (proc->video) ? "video input" : "window output");
-            rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_UNSUPPORTED,
-                             __func__, "no compatible image format");
-        }
-    }
-
- done:
-    _zbar_mutex_lock(&proc->mutex);
-    proc_leave(proc);
-    return(rc);
-}
-
-zbar_image_data_handler_t*
-zbar_processor_set_data_handler (zbar_processor_t *proc,
-                                 zbar_image_data_handler_t *handler,
-                                 const void *userdata)
-{
-    zbar_image_data_handler_t *result = NULL;
-    proc_enter(proc);
-
-    result = proc->handler;
-    proc->handler = handler;
-    proc->userdata = userdata;
-
-    proc_leave(proc);
-    return(result);
-}
-
-void zbar_processor_set_userdata (zbar_processor_t *proc,
-                                  void *userdata)
-{
-    _zbar_mutex_lock(&proc->mutex);
-    proc->userdata = userdata;
-    _zbar_mutex_unlock(&proc->mutex);
-}
-
-void *zbar_processor_get_userdata (const zbar_processor_t *proc)
-{
-    zbar_processor_t *ncproc = (zbar_processor_t*)proc;
-    _zbar_mutex_lock(&ncproc->mutex);
-    void *userdata = (void*)ncproc->userdata;
-    _zbar_mutex_unlock(&ncproc->mutex);
-    return(userdata);
-}
-
-int zbar_processor_set_config (zbar_processor_t *proc,
-                               zbar_symbol_type_t sym,
-                               zbar_config_t cfg,
-                               int val)
-{
-    proc_enter(proc);
-    int rc = zbar_image_scanner_set_config(proc->scanner, sym, cfg, val);
-    proc_leave(proc);
-    return(rc);
-}
-
-int zbar_processor_request_size (zbar_processor_t *proc,
-                                 unsigned width,
-                                 unsigned height)
-{
-    proc_enter(proc);
-    proc->req_width = width;
-    proc->req_height = height;
-    proc_leave(proc);
-    return(0);
-}
-
-int zbar_processor_request_interface (zbar_processor_t *proc,
-                                      int ver)
-{
-    proc_enter(proc);
-    proc->req_intf = ver;
-    proc_leave(proc);
-    return(0);
-}
-
-int zbar_processor_request_iomode (zbar_processor_t *proc,
-                                   int iomode)
-{
-    proc_enter(proc);
-    proc->req_iomode = iomode;
-    proc_leave(proc);
-    return(0);
-}
-
-int zbar_processor_force_format (zbar_processor_t *proc,
-                                 unsigned long input,
-                                 unsigned long output)
-{
-    proc_enter(proc);
-    proc->force_input = input;
-    proc->force_output = output;
-    proc_leave(proc);
-    return(0);
-}
-
-int zbar_processor_is_visible (zbar_processor_t *proc)
-{
-    proc_enter(proc);
-    int visible = proc->window && proc->visible;
-    proc_leave(proc);
-    return(visible);
-}
-
-int zbar_processor_set_visible (zbar_processor_t *proc,
-                                int visible)
-{
-    proc_enter(proc);
-    _zbar_mutex_unlock(&proc->mutex);
-
-    int rc = 0;
-    if(proc->window) {
-        if(proc->video)
-            rc = _zbar_processor_set_size(proc,
-                                          zbar_video_get_width(proc->video),
-                                          zbar_video_get_height(proc->video));
-        if(!rc)
-            rc = _zbar_processor_set_visible(proc, visible);
-
-        if(!rc)
-            proc->visible = (visible != 0);
-    }
-    else if(visible)
-        rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_INVALID, __func__,
-                         "processor display window not initialized");
-
-    _zbar_mutex_lock(&proc->mutex);
-    proc_leave(proc);
-    return(rc);
-}
-
-const zbar_symbol_set_t*
-zbar_processor_get_results (const zbar_processor_t *proc)
-{
-    zbar_processor_t *ncproc = (zbar_processor_t*)proc;
-    proc_enter(ncproc);
-    const zbar_symbol_set_t *syms = proc->syms;
-    if(syms)
-        zbar_symbol_set_ref(syms, 1);
-    proc_leave(ncproc);
-    return(syms);
-}
-
-int zbar_processor_user_wait (zbar_processor_t *proc,
-                              int timeout)
-{
-    proc_enter(proc);
-    _zbar_mutex_unlock(&proc->mutex);
-
-    int rc = -1;
-    if(proc->visible || proc->streaming || timeout >= 0) {
-        zbar_timer_t timer;
-        rc = _zbar_processor_wait(proc, EVENT_INPUT,
-                                  _zbar_timer_init(&timer, timeout));
-    }
-
-    if(!proc->visible)
-        rc = err_capture(proc, SEV_WARNING, ZBAR_ERR_CLOSED, __func__,
-                         "display window not available for input");
-
-    if(rc > 0)
-        rc = proc->input;
-
-    _zbar_mutex_lock(&proc->mutex);
-    proc_leave(proc);
-    return(rc);
-}
-
-int zbar_processor_set_active (zbar_processor_t *proc,
-                               int active)
-{
-    proc_enter(proc);
-
-    int rc;
-    if(!proc->video) {
-        rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_INVALID, __func__,
-                         "video input not initialized");
-        goto done;
-    }
-    _zbar_mutex_unlock(&proc->mutex);
-
-    zbar_image_scanner_enable_cache(proc->scanner, active);
-
-    rc = zbar_video_enable(proc->video, active);
-    if(!rc) {
-        _zbar_mutex_lock(&proc->mutex);
-        proc->streaming = active;
-        _zbar_mutex_unlock(&proc->mutex);
-        rc = _zbar_processor_enable(proc);
-    }
-    else
-        err_copy(proc, proc->video);
-
-    if(!proc->streaming && proc->window) {
-        if(zbar_window_draw(proc->window, NULL) && !rc)
-            rc = err_copy(proc, proc->window);
-        _zbar_processor_invalidate(proc);
-    }
-
-    _zbar_mutex_lock(&proc->mutex);
-    if(proc->video_thread.started)
-        _zbar_event_trigger(&proc->video_thread.notify);
-
- done:
-    proc_leave(proc);
-    return(rc);
-}
-
-int zbar_process_one (zbar_processor_t *proc,
-                      int timeout)
-{
-    proc_enter(proc);
-    int streaming = proc->streaming;
-    _zbar_mutex_unlock(&proc->mutex);
-
-    int rc = 0;
-    if(!proc->video) {
-        rc = err_capture(proc, SEV_ERROR, ZBAR_ERR_INVALID, __func__,
-                         "video input not initialized");
-        goto done;
-    }
-
-    if(!streaming) {
-        rc = zbar_processor_set_active(proc, 1);
-        if(rc)
-            goto done;
-    }
-
-    zbar_timer_t timer;
-    rc = _zbar_processor_wait(proc, EVENT_OUTPUT,
-                              _zbar_timer_init(&timer, timeout));
-
-    if(!streaming && zbar_processor_set_active(proc, 0))
-        rc = -1;
-
- done:
-    _zbar_mutex_lock(&proc->mutex);
-    proc_leave(proc);
-    return(rc);
-}
-
-int zbar_process_image (zbar_processor_t *proc,
-                        zbar_image_t *img)
-{
-    proc_enter(proc);
-    _zbar_mutex_unlock(&proc->mutex);
-
-    int rc = 0;
-    if(img && proc->window)
-        rc = _zbar_processor_set_size(proc,
-                                      zbar_image_get_width(img),
-                                      zbar_image_get_height(img));
-    if(!rc) {
-        zbar_image_scanner_enable_cache(proc->scanner, 0);
-        rc = _zbar_process_image(proc, img);
-        if(proc->streaming)
-            zbar_image_scanner_enable_cache(proc->scanner, 1);
-    }
-
-    _zbar_mutex_lock(&proc->mutex);
-    proc_leave(proc);
-    return(rc);
-}