static int
image_clear (zbarImage *self)
{
zbar_image_t *zimg = self->zimg;
self->zimg = NULL;
if(zimg) {
assert(zbar_image_get_userdata(zimg) == self);
if(self->data) {
/* attach data directly to zbar image */
zbar_image_set_userdata(zimg, self->data);
self->data = NULL;
}
else
zbar_image_set_userdata(zimg, NULL);
zbar_image_destroy(zimg);
}
return(0);
}
void zbar_gtk_release_pixbuf (zbar_image_t *img)
{
GdkPixbuf *pixbuf = zbar_image_get_userdata(img);
g_assert(GDK_IS_PIXBUF(pixbuf));
/* remove reference */
zbar_image_set_userdata(img, NULL);
/* release reference to associated pixbuf and it's data */
g_object_unref(pixbuf);
}
zbarImage*
zbarImage_FromImage (zbar_image_t *zimg)
{
zbarImage *self = PyObject_GC_New(zbarImage, &zbarImage_Type);
if(!self)
return(NULL);
zbar_image_ref(zimg, 1);
zbar_image_set_userdata(zimg, self);
self->zimg = zimg;
self->data = NULL;
return(self);
}
void
image_cleanup (zbar_image_t *zimg)
{
PyObject *data = zbar_image_get_userdata(zimg);
zbar_image_set_userdata(zimg, NULL);
if(!data)
return; /* FIXME internal error */
if(PyObject_TypeCheck(data, &zbarImage_Type)) {
zbarImage *self = (zbarImage*)data;
assert(self->zimg == zimg);
Py_CLEAR(self->data);
}
else
Py_DECREF(data);
}
static inline void
Image_setData (JNIEnv *env,
jobject obj,
jbyteArray data,
void *raw,
unsigned long rawlen,
zbar_image_cleanup_handler_t *cleanup)
{
if(!data)
cleanup = NULL;
(*env)->SetObjectField(env, obj, Image_data, data);
zbar_image_t *zimg = GET_PEER(Image, obj);
zbar_image_set_data(zimg, raw, rawlen, cleanup);
zbar_image_set_userdata(zimg, (*env)->NewGlobalRef(env, data));
}
static zbarImage*
image_new (PyTypeObject *type,
PyObject *args,
PyObject *kwds)
{
zbarImage *self = (zbarImage*)type->tp_alloc(type, 0);
if(!self)
return(NULL);
self->zimg = zbar_image_create();
if(!self->zimg) {
Py_DECREF(self);
return(NULL);
}
zbar_image_set_userdata(self->zimg, self);
return(self);
}
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 zbarImage*
image_convert (zbarImage *self,
PyObject *args,
PyObject *kwds)
{
const char *format = NULL;
int width = -1, height = -1;
static char *kwlist[] = { "format", "width", "height", NULL };
if(!PyArg_ParseTupleAndKeywords(args, kwds, "s|ii", kwlist,
&format, &width, &height))
return(NULL);
assert(format);
if(strlen(format) != 4) {
PyErr_Format(PyExc_ValueError,
"format '%.50s' is not a valid four character code",
format);
return(NULL);
}
zbarImage *img = PyObject_GC_New(zbarImage, &zbarImage_Type);
if(!img)
return(NULL);
img->data = NULL;
if(width > 0 && height > 0)
img->zimg =
zbar_image_convert_resize(self->zimg,
*((unsigned long*)format),
width, height);
else
img->zimg = zbar_image_convert(self->zimg, *((unsigned long*)format));
if(!img->zimg) {
/* FIXME propagate exception */
Py_DECREF(img);
return(NULL);
}
zbar_image_set_userdata(img->zimg, img);
return(img);
}
static int
image_set_data (zbarImage *self,
PyObject *value,
void *closure)
{
if(!value) {
zbar_image_free_data(self->zimg);
return(0);
}
char *data;
Py_ssize_t datalen;
if(PyString_AsStringAndSize(value, &data, &datalen))
return(-1);
Py_INCREF(value);
zbar_image_set_data(self->zimg, data, datalen, image_cleanup);
assert(!self->data);
self->data = value;
zbar_image_set_userdata(self->zimg, self);
return(0);
}
gboolean zbar_gtk_image_from_pixbuf (zbar_image_t *zimg,
GdkPixbuf *pixbuf)
{
/* apparently should always be packed RGB? */
GdkColorspace colorspace = gdk_pixbuf_get_colorspace(pixbuf);
if(colorspace != GDK_COLORSPACE_RGB) {
g_warning("non-RGB color space not supported: %d\n", colorspace);
return(FALSE);
}
int nchannels = gdk_pixbuf_get_n_channels(pixbuf);
int bps = gdk_pixbuf_get_bits_per_sample(pixbuf);
long type = 0;
/* these are all guesses... */
if(nchannels == 3 && bps == 8)
type = fourcc('R','G','B','3');
else if(nchannels == 4 && bps == 8)
type = fourcc('B','G','R','4'); /* FIXME alpha flipped?! */
else if(nchannels == 1 && bps == 8)
type = fourcc('Y','8','0','0');
else if(nchannels == 3 && bps == 5)
type = fourcc('R','G','B','R');
else if(nchannels == 3 && bps == 4)
type = fourcc('R','4','4','4'); /* FIXME maybe? */
else {
g_warning("unsupported combination: nchannels=%d bps=%d\n",
nchannels, bps);
return(FALSE);
}
zbar_image_set_format(zimg, type);
/* FIXME we don't deal w/bpl...
* this will cause problems w/unpadded pixbufs :|
*/
unsigned pitch = gdk_pixbuf_get_rowstride(pixbuf);
unsigned width = pitch / ((nchannels * bps) / 8);
if((width * nchannels * 8 / bps) != pitch) {
g_warning("unsupported: width=%d nchannels=%d bps=%d rowstride=%d\n",
width, nchannels, bps, pitch);
return(FALSE);
}
unsigned height = gdk_pixbuf_get_height(pixbuf);
/* FIXME this isn't correct either */
unsigned long datalen = width * height * nchannels;
zbar_image_set_size(zimg, width, height);
/* when the zbar image is released, the pixbuf will be
* automatically be released
*/
zbar_image_set_userdata(zimg, pixbuf);
zbar_image_set_data(zimg, gdk_pixbuf_get_pixels(pixbuf), datalen,
zbar_gtk_release_pixbuf);
#ifdef DEBUG_ZBARGTK
g_message("colorspace=%d nchannels=%d bps=%d type=%.4s(%08lx)\n"
"\tpitch=%d width=%d height=%d datalen=0x%lx\n",
colorspace, nchannels, bps, (char*)&type, type,
pitch, width, height, datalen);
#endif
return(TRUE);
}
