JNIEXPORT jobject JNICALL
Java_net_sourceforge_zbar_Image_getData (JNIEnv *env,
jobject obj)
{
jobject data = (*env)->GetObjectField(env, obj, Image_data);
if(data)
return(data);
zbar_image_t *zimg = GET_PEER(Image, obj);
data = zbar_image_get_userdata(zimg);
if(data)
return(data);
unsigned long rawlen = zbar_image_get_data_length(zimg);
const void *raw = zbar_image_get_data(zimg);
if(!rawlen || !raw)
return(NULL);
data = (*env)->NewByteArray(env, rawlen);
if(!data)
return(NULL);
(*env)->SetByteArrayRegion(env, data, 0, rawlen, raw);
(*env)->SetObjectField(env, obj, Image_data, data);
return(data);
}
static void test_cleanup_handler (zbar_image_t *img)
{
void *data = (void*)zbar_image_get_data(img);
fprintf(stderr, "cleanup image data @%p\n", data);
free(data);
allocated_images--;
}
int
zbarImage_validate (zbarImage *img)
{
if(!zbar_image_get_width(img->zimg) ||
!zbar_image_get_height(img->zimg) ||
!zbar_image_get_data(img->zimg) ||
!zbar_image_get_data_length(img->zimg)) {
PyErr_Format(PyExc_ValueError, "image size and data must be defined");
return(-1);
}
return(0);
}
static void
Image_cleanupIntArray (zbar_image_t *zimg)
{
jobject data = zbar_image_get_userdata(zimg);
assert(data);
JNIEnv *env = NULL;
if((*jvm)->AttachCurrentThread(jvm, (void**)&env, NULL))
return;
assert(env);
if(env && data) {
void *raw = (void*)zbar_image_get_data(zimg);
assert(raw);
/* const image data is unchanged - abort copy back */
(*env)->ReleaseIntArrayElements(env, data, raw, JNI_ABORT);
(*env)->DeleteGlobalRef(env, data);
zbar_image_set_userdata(zimg, NULL);
}
}
static PyObject*
image_get_data (zbarImage *self,
void *closure)
{
assert(zbar_image_get_userdata(self->zimg) == self);
if(self->data) {
Py_INCREF(self->data);
return(self->data);
}
const char *data = zbar_image_get_data(self->zimg);
unsigned long datalen = zbar_image_get_data_length(self->zimg);
if(!data || !datalen) {
Py_INCREF(Py_None);
return(Py_None);
}
self->data = PyBuffer_FromMemory((void*)data, datalen);
Py_INCREF(self->data);
return(self->data);
}
/* 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_scan_image (zbar_image_scanner_t *iscn,
zbar_image_t *img)
{
recycle_syms(iscn, img);
/* get grayscale image, convert if necessary */
img = zbar_image_convert(img, fourcc('Y','8','0','0'));
if(!img)
return(-1);
unsigned w = zbar_image_get_width(img);
unsigned h = zbar_image_get_height(img);
const uint8_t *data = zbar_image_get_data(img);
/* FIXME less arbitrary lead-out default */
int quiet = w / 32;
if(quiet < 8)
quiet = 8;
int density = CFG(iscn, ZBAR_CFG_Y_DENSITY);
if(density > 0) {
const uint8_t *p = data;
int x = 0, y = 0;
int border = (((h - 1) % density) + 1) / 2;
if(border > h / 2)
border = h / 2;
movedelta(0, border);
if(zbar_scanner_new_scan(iscn->scn))
symbol_handler(iscn, x, y);
while(y < h) {
zprintf(32, "img_x+: %03x,%03x @%p\n", x, y, p);
while(x < w) {
ASSERT_POS;
if(zbar_scan_y(iscn->scn, *p))
symbol_handler(iscn, x, y);
movedelta(1, 0);
}
quiet_border(iscn, quiet, x, y);
movedelta(-1, density);
if(y >= h)
break;
zprintf(32, "img_x-: %03x,%03x @%p\n", x, y, p);
while(x > 0) {
ASSERT_POS;
if(zbar_scan_y(iscn->scn, *p))
symbol_handler(iscn, x, y);
movedelta(-1, 0);
}
quiet_border(iscn, quiet, x, y);
movedelta(1, density);
}
}
density = CFG(iscn, ZBAR_CFG_X_DENSITY);
if(density > 0) {
const uint8_t *p = data;
int x = 0, y = 0;
int border = (((w - 1) % density) + 1) / 2;
if(border > w / 2)
border = w / 2;
movedelta(border, 0);
while(x < w) {
zprintf(32, "img_y+: %03x,%03x @%p\n", x, y, p);
while(y < h) {
ASSERT_POS;
if(zbar_scan_y(iscn->scn, *p))
symbol_handler(iscn, x, y);
movedelta(0, 1);
}
quiet_border(iscn, quiet, x, y);
movedelta(density, -1);
if(x >= w)
break;
zprintf(32, "img_y-: %03x,%03x @%p\n", x, y, p);
while(y >= 0) {
ASSERT_POS;
if(zbar_scan_y(iscn->scn, *p))
symbol_handler(iscn, x, y);
movedelta(0, -1);
}
quiet_border(iscn, quiet, x, y);
movedelta(density, 1);
}
}
/* release reference to converted image */
zbar_image_destroy(img);
return(iscn->img->nsyms);
}
