int zbar_processor_init (zbar_processor_t *proc,
const char *dev,
int enable_display)
{
int rc, input_threaded;
_zbar_mutex_lock(&proc->mutex);
_zbar_thread_stop(&proc->input_thread, &proc->mutex);
_zbar_processor_lock(proc);
_zbar_mutex_unlock(&proc->mutex);
rc = 0;
if(!dev && !enable_display)
/* nothing to do */
goto done;
/* spawn input monitor thread */
input_threaded = proc->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;
}
done:
_zbar_mutex_lock(&proc->mutex);
proc_leave(proc);
return(rc);
}
static ZTHREAD proc_input_thread (void *arg)
{
zbar_processor_t *proc = arg;
zbar_thread_t *thread = &proc->input_thread;
int rc;
_zbar_mutex_lock(&proc->mutex);
thread->running = 1;
_zbar_event_trigger(&thread->activity);
zprintf(4, "spawned input thread\n");
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);
thread->running = 0;
_zbar_event_trigger(&thread->activity);
_zbar_mutex_unlock(&proc->mutex);
return(0);
}
void zbar_processor_set_userdata (zbar_processor_t *proc,
void *userdata)
{
_zbar_mutex_lock(&proc->mutex);
proc->userdata = userdata;
_zbar_mutex_unlock(&proc->mutex);
}
static __inline int proc_wait_unthreaded (zbar_processor_t *proc,
proc_waiter_t *waiter,
zbar_timer_t *timeout)
{
int blocking = 0;// 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_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 '=':
break;
case '-':
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);
}
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_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);
}
int zbar_processor_user_wait (zbar_processor_t *proc,
int timeout)
{
int rc;
proc_enter(proc);
_zbar_mutex_unlock(&proc->mutex);
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);
}
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);
}
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);
}
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);
}
static ZTHREAD vfw_capture_thread (void *arg)
{
zbar_video_t *vdo = arg;
video_state_t *state = vdo->state;
zbar_thread_t *thr = &state->thread;
state->hwnd = capCreateCaptureWindow(NULL, WS_POPUP, 0, 0, 1, 1, NULL, 0);
if(!state->hwnd)
goto done;
_zbar_mutex_lock(&vdo->qlock);
_zbar_thread_init(thr);
zprintf(4, "spawned vfw capture thread (thr=%04lx)\n",
_zbar_thread_self());
MSG msg;
int rc = 0;
while(thr->started && rc >= 0 && rc <= 1) {
_zbar_mutex_unlock(&vdo->qlock);
rc = MsgWaitForMultipleObjects(1, &thr->notify, 0,
INFINITE, QS_ALLINPUT);
if(rc == 1)
while(PeekMessage(&msg, NULL, 0, 0, PM_NOYIELD | PM_REMOVE))
if(rc > 0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
_zbar_mutex_lock(&vdo->qlock);
}
done:
thr->running = 0;
_zbar_event_trigger(&thr->activity);
_zbar_mutex_unlock(&vdo->qlock);
return(0);
}
int zbar_processor_set_visible (zbar_processor_t *proc,
int visible)
{
int rc = 0;
proc_enter(proc);
_zbar_mutex_unlock(&proc->mutex);
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);
}
static LRESULT CALLBACK vfw_stream_cb (HWND hwnd,
VIDEOHDR *hdr)
{
if(!hwnd || !hdr)
return(0);
zbar_video_t *vdo = (void*)capGetUserData(hwnd);
_zbar_mutex_lock(&vdo->qlock);
zbar_image_t *img = vdo->state->image;
if(!img) {
_zbar_mutex_lock(&vdo->qlock);
img = video_dq_image(vdo);
}
if(img) {
img->data = hdr->lpData;
img->datalen = hdr->dwBufferLength;
vdo->state->image = img;
SetEvent(vdo->state->captured);
}
_zbar_mutex_unlock(&vdo->qlock);
return(1);
}
static int vfw_stop (zbar_video_t *vdo)
{
video_state_t *state = vdo->state;
if(!capCaptureAbort(state->hwnd))
return(err_capture(vdo, SEV_ERROR, ZBAR_ERR_INVALID, __func__,
"stopping video stream"));
_zbar_mutex_lock(&vdo->qlock);
if(state->image)
state->image = NULL;
SetEvent(state->captured);
_zbar_mutex_unlock(&vdo->qlock);
return(0);
}
static LRESULT CALLBACK vfw_error_cb (HWND hwnd,
int errid,
const char *errmsg)
{
if(!hwnd)
return(0);
zbar_video_t *vdo = (void*)capGetUserData(hwnd);
zprintf(2, "id=%d msg=%s\n", errid, errmsg);
_zbar_mutex_lock(&vdo->qlock);
vdo->state->image = NULL;
SetEvent(vdo->state->captured);
_zbar_mutex_unlock(&vdo->qlock);
return(1);
}
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);
return(-1);
}
/* lock must be held */
int _zbar_event_wait (zbar_event_t *event,
zbar_mutex_t *lock,
zbar_timer_t *timeout)
{
if(lock)
_zbar_mutex_unlock(lock);
int rc = WaitForSingleObject(*event, _zbar_timer_check(timeout));
if(lock)
_zbar_mutex_lock(lock);
if(!rc)
return(1); /* got event */
if(rc == WAIT_TIMEOUT)
return(0); /* timed out */
return(-1); /* error (FIXME save info) */
}
int zbar_process_image (zbar_processor_t *proc,
zbar_image_t *img)
{
int rc;
proc_enter(proc);
_zbar_mutex_unlock(&proc->mutex);
rc = 0;
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);
}
static zbar_image_t *vfw_dq (zbar_video_t *vdo)
{
zbar_image_t *img = vdo->state->image;
if(!img) {
_zbar_mutex_unlock(&vdo->qlock);
int rc = WaitForSingleObject(vdo->state->captured, INFINITE);
_zbar_mutex_lock(&vdo->qlock);
if(!rc)
img = vdo->state->image;
else
img = NULL;
/*FIXME handle errors? */
}
else
ResetEvent(vdo->state->captured);
if(img)
vdo->state->image = NULL;
video_unlock(vdo);
return(img);
}
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);
}
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);
}
static __inline int proc_enter (zbar_processor_t *proc)
{
_zbar_mutex_lock(&proc->mutex);
return(_zbar_processor_lock(proc));
}
/* 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 nsyms, rc;
if(img) {
zbar_image_t *tmp;
uint32_t format = zbar_image_get_format(img);
zprintf(16, "processing: %.4s(%08lx) %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) (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_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(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_init (zbar_processor_t *proc,
const char *dev,
int enable_display)
{
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;
}
int 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 */
int 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);
}