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);
}
static int
processor_set_bool (zbarProcessor *self,
PyObject *value,
void *closure)
{
if(!value) {
PyErr_SetString(PyExc_TypeError, "cannot delete attribute");
return(-1);
}
int rc, val = PyObject_IsTrue(value);
if(val < 0)
return(-1);
switch((intptr_t)closure) {
case 0:
rc = zbar_processor_set_visible(self->zproc, val);
break;
case 1:
rc = zbar_processor_set_active(self->zproc, val);
break;
default:
assert(0);
return(-1);
}
if(rc < 0) {
zbarErr_Set((PyObject*)self);
return(-1);
}
return(0);
}
int main (int argc, char **argv)
{
const char *device = "/dev/video0";
/* create a Processor */
zbar_processor_t *proc = zbar_processor_create(1);
/* configure the Processor */
zbar_processor_set_config(proc, 0, ZBAR_CFG_ENABLE, 1);
/* initialize the Processor */
if(argc > 1)
device = argv[1];
zbar_processor_init(proc, device, 1);
/* setup a callback */
zbar_processor_set_data_handler(proc, my_handler, NULL);
/* enable the preview window */
zbar_processor_set_visible(proc, 1);
zbar_processor_set_active(proc, 1);
/* keep scanning until user provides key/mouse input */
zbar_processor_user_wait(proc, -1);
/* clean up */
zbar_processor_destroy(proc);
return(0);
}
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);
}
int main (int argc, const char *argv[])
{
/* setup zbar library standalone processor,
* threads will be used if available
*/
proc = zbar_processor_create(1);
if(!proc) {
fprintf(stderr, "ERROR: unable to allocate memory?\n");
return(1);
}
zbar_processor_set_data_handler(proc, data_handler, NULL);
const char *video_device = "";
int display = 1;
unsigned long infmt = 0, outfmt = 0;
int i;
for(i = 1; i < argc; i++) {
if(argv[i][0] != '-')
video_device = argv[i];
else if(argv[i][1] != '-') {
int j;
for(j = 1; argv[i][j]; j++) {
if(argv[i][j] == 'S') {
if(!argv[i][++j]) {
i++;
j = 0;
}
if(parse_config(&argv[i][j], i, argc, "-S"))
return(usage(1));
break;
}
switch(argv[i][j]) {
case 'h': return(usage(0));
case 'v': zbar_increase_verbosity(); break;
case 'q': quiet = 1; break;
default:
fprintf(stderr, "ERROR: unknown bundled config: -%c\n\n",
argv[i][j]);
return(usage(1));
}
}
}
else if(!argv[i][2]) {
if(i < argc - 1)
video_device = argv[argc - 1];
break;
}
else if(!strcmp(argv[i], "--help"))
return(usage(0));
else if(!strcmp(argv[i], "--version"))
return(printf(PACKAGE_VERSION "\n") <= 0);
else if(!strcmp(argv[i], "--set")) {
i++;
if(parse_config(argv[i], i, argc, "--set"))
return(usage(1));
}
else if(!strncmp(argv[i], "--set=", 6)) {
if(parse_config(&argv[i][6], i, argc, "--set="))
return(usage(1));
}
else if(!strcmp(argv[i], "--quiet"))
quiet = 1;
else if(!strcmp(argv[i], "--xml"))
format = XML;
else if(!strcmp(argv[i], "--raw"))
format = RAW;
else if(!strcmp(argv[i], "--nodisplay"))
display = 0;
else if(!strcmp(argv[i], "--verbose"))
zbar_increase_verbosity();
else if(!strncmp(argv[i], "--verbose=", 10))
zbar_set_verbosity(strtol(argv[i] + 10, NULL, 0));
else if(!strncmp(argv[i], "--prescale=", 11)) {
char *x = NULL;
long int w = strtol(argv[i] + 11, &x, 10);
long int h = 0;
if(x && *x == 'x')
h = strtol(x + 1, NULL, 10);
if(!w || !h || !x || *x != 'x') {
fprintf(stderr, "ERROR: invalid prescale: %s\n\n", argv[i]);
return(usage(1));
}
zbar_processor_request_size(proc, w, h);
}
else if(!strncmp(argv[i], "--v4l=", 6)) {
long int v = strtol(argv[i] + 6, NULL, 0);
zbar_processor_request_interface(proc, v);
}
else if(!strncmp(argv[i], "--iomode=", 9)) {
long int v = strtol(argv[i] + 9, NULL, 0);
zbar_processor_request_iomode(proc, v);
}
else if(!strncmp(argv[i], "--infmt=", 8) &&
strlen(argv[i]) == 12)
infmt = (argv[i][8] | (argv[i][9] << 8) |
(argv[i][10] << 16) | (argv[i][11] << 24));
else if(!strncmp(argv[i], "--outfmt=", 9) &&
strlen(argv[i]) == 13)
outfmt = (argv[i][9] | (argv[i][10] << 8) |
(argv[i][11] << 16) | (argv[i][12] << 24));
else {
fprintf(stderr, "ERROR: unknown option argument: %s\n\n",
argv[i]);
return(usage(1));
}
}
if(infmt || outfmt)
zbar_processor_force_format(proc, infmt, outfmt);
/* open video device, open window */
if(zbar_processor_init(proc, video_device, display) ||
/* show window */
(display && zbar_processor_set_visible(proc, 1)))
return(zbar_processor_error_spew(proc, 0));
if(format == XML) {
#ifdef _WIN32
fflush(stdout);
_setmode(_fileno(stdout), _O_BINARY);
#endif
printf(xml_head, video_device);
fflush(stdout);
}
/* start video */
int active = 1;
if(zbar_processor_set_active(proc, active))
return(zbar_processor_error_spew(proc, 0));
/* let the callback handle data */
int rc;
while((rc = zbar_processor_user_wait(proc, -1)) >= 0) {
if(rc == 'q' || rc == 'Q')
break;
if(rc == ' ') {
active = !active;
if(zbar_processor_set_active(proc, active))
return(zbar_processor_error_spew(proc, 0));
}
}
/* report any errors that aren't "window closed" */
if(rc && rc != 'q' && rc != 'Q' &&
zbar_processor_get_error_code(proc) != ZBAR_ERR_CLOSED)
return(zbar_processor_error_spew(proc, 0));
/* free resources (leak check) */
zbar_processor_destroy(proc);
if(format == XML) {
printf("%s", xml_foot);
fflush(stdout);
}
return(0);
}
