zbar_video_t *zbar_video_create ()
{
zbar_video_t *vdo = calloc(1, sizeof(zbar_video_t));
int i;
if(!vdo)
return(NULL);
err_init(&vdo->err, ZBAR_MOD_VIDEO);
vdo->fd = -1;
(void)_zbar_mutex_init(&vdo->qlock);
/* pre-allocate images */
vdo->num_images = ZBAR_VIDEO_IMAGES_MAX;
vdo->images = calloc(ZBAR_VIDEO_IMAGES_MAX, sizeof(zbar_image_t*));
if(!vdo->images) {
zbar_video_destroy(vdo);
return(NULL);
}
for(i = 0; i < ZBAR_VIDEO_IMAGES_MAX; i++) {
zbar_image_t *img = vdo->images[i] = zbar_image_create();
if(!img) {
zbar_video_destroy(vdo);
return(NULL);
}
img->refcnt = 0;
img->cleanup = _zbar_video_recycle_image;
img->srcidx = i;
img->src = vdo;
}
return(vdo);
}
static void zbar_gtk_private_finalize (GObject *object)
{
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(object);
if(zbar->window) {
zbar_window_destroy(zbar->window);
zbar->window = NULL;
}
if(zbar->scanner) {
zbar_image_scanner_destroy(zbar->scanner);
zbar->scanner = NULL;
}
if(zbar->video) {
zbar_video_destroy(zbar->video);
zbar->video = NULL;
}
g_async_queue_unref(zbar->queue);
zbar->queue = NULL;
}
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);
}
static inline gboolean zbar_gtk_video_open (ZBarGtk *self,
const char *video_device)
{
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
gboolean video_opened = FALSE;
gdk_threads_enter();
zbar->req_width = DEFAULT_WIDTH;
zbar->req_height = DEFAULT_HEIGHT;
gtk_widget_queue_resize(GTK_WIDGET(self));
zbar->video_opened = FALSE;
if(zbar->thread)
g_object_notify(G_OBJECT(self), "video-opened");
if(zbar->window) {
/* ensure old video doesn't have image ref
* (FIXME handle video destroyed w/images outstanding)
*/
zbar_window_draw(zbar->window, NULL);
gtk_widget_queue_draw(GTK_WIDGET(self));
}
gdk_threads_leave();
if(zbar->video) {
zbar_video_destroy(zbar->video);
zbar->video = NULL;
}
if(video_device && video_device[0] && zbar->thread) {
/* create video
* FIXME video should support re-open
*/
zbar->video = zbar_video_create();
g_assert(zbar->video);
if(zbar_video_open(zbar->video, video_device)) {
zbar_video_error_spew(zbar->video, 0);
zbar_video_destroy(zbar->video);
zbar->video = NULL;
/* FIXME error propagation */
return(FALSE);
}
/* negotiation accesses the window format list,
* so we hold the lock for this part
*/
gdk_threads_enter();
video_opened = !zbar_negotiate_format(zbar->video, zbar->window);
if(video_opened) {
zbar->req_width = zbar_video_get_width(zbar->video);
zbar->req_height = zbar_video_get_height(zbar->video);
}
gtk_widget_queue_resize(GTK_WIDGET(self));
zbar->video_opened = video_opened;
if(zbar->thread)
g_object_notify(G_OBJECT(self), "video-opened");
gdk_threads_leave();
}
return(video_opened);
}
