static inline int zbar_gtk_process_image (ZBarGtk *self,
zbar_image_t *image)
{
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
if(!image)
return(-1);
zbar_image_t *tmp = zbar_image_convert(image, fourcc('Y','8','0','0'));
if(!tmp)
return(-1);
zbar_image_scanner_recycle_image(zbar->scanner, image);
int rc = zbar_scan_image(zbar->scanner, tmp);
zbar_image_set_symbols(image, zbar_image_get_symbols(tmp));
zbar_image_destroy(tmp);
if(rc < 0)
return(rc);
gdk_threads_enter();
if(rc && zbar->thread) {
/* update decode results */
const zbar_symbol_t *sym;
for(sym = zbar_image_first_symbol(image);
sym;
sym = zbar_symbol_next(sym))
if(!zbar_symbol_get_count(sym)) {
zbar_symbol_type_t type = zbar_symbol_get_type(sym);
const char *data = zbar_symbol_get_data(sym);
g_signal_emit(self, zbar_gtk_signals[DECODED], 0,
type, data);
/* FIXME skip this when unconnected? */
gchar *text = g_strconcat(zbar_get_symbol_name(type),
zbar_get_addon_name(type),
":",
data,
NULL);
g_signal_emit(self, zbar_gtk_signals[DECODED_TEXT], 0, text);
g_free(text);
}
}
if(zbar->window) {
rc = zbar_window_draw(zbar->window, image);
gtk_widget_queue_draw(GTK_WIDGET(self));
}
else
rc = -1;
gdk_threads_leave();
return(rc);
}
/* decode signal callback
* puts the decoded result in the textbox
*/
static void decoded (GtkWidget *widget,
zbar_symbol_type_t symbol,
const char *result,
gpointer data)
{
GtkTextBuffer *resultbuf = gtk_text_view_get_buffer(results);
GtkTextIter end;
gtk_text_buffer_get_end_iter(resultbuf, &end);
gtk_text_buffer_insert(resultbuf, &end, zbar_get_symbol_name(symbol), -1);
gtk_text_buffer_insert(resultbuf, &end, zbar_get_addon_name(symbol), -1);
gtk_text_buffer_insert(resultbuf, &end, ":", -1);
gtk_text_buffer_insert(resultbuf, &end, result, -1);
gtk_text_buffer_insert(resultbuf, &end, "\n", -1);
gtk_text_view_scroll_to_iter(results, &end, 0, FALSE, 0, 0);
}
int main (int argc, const char *argv[])
{
processor = zbar_processor_create(0);
assert(processor);
if(zbar_processor_init(processor, NULL, 0)) {
zbar_processor_error_spew(processor, 0);
return(1);
}
zbar_image_t *zimage = zbar_image_create();
assert(zimage);
zbar_image_set_format(zimage, *(unsigned long*)"Y800");
int width = js_get_width();
int height = js_get_height();
zbar_image_set_size(zimage, width, height);
size_t bloblen = width * height;
unsigned char *blob = malloc(bloblen);
zbar_image_set_data(zimage, blob, bloblen, zbar_image_free_data);
js_read_image(blob, bloblen);
zbar_process_image(processor, zimage);
// print results
const zbar_symbol_t *sym = zbar_image_first_symbol(zimage);
for(; sym; sym = zbar_symbol_next(sym)) {
zbar_symbol_type_t typ = zbar_symbol_get_type(sym);
if(typ == ZBAR_PARTIAL)
continue;
js_output_result(zbar_get_symbol_name(typ),
zbar_get_addon_name(typ),
zbar_symbol_get_data(sym));
}
zbar_image_destroy(zimage);
if(zbar_processor_is_visible(processor)) {
zbar_processor_user_wait(processor, -1);
}
zbar_processor_destroy(processor);
return 0;
}
static int scan_image (IplImage * image)
{
if(exit_code == 3)
return(-1);
int found = 0;
if(exit_code == 3)
return(-1);
zbar_image_t *zimage = zbar_image_create();
assert(zimage);
zbar_image_set_format(zimage, *(unsigned long*)"Y800");
int width = image->width;
int height = image->height;
zbar_image_set_size(zimage, width, height);
// extract grayscale image pixels
// FIXME color!! ...preserve most color w/422P
// (but only if it's a color image)
size_t bloblen = width * height;
unsigned char *blob = malloc(bloblen);
zbar_image_set_data(zimage, blob, bloblen, zbar_image_free_data);
memcpy(blob, image->imageData, image->imageSize);
if(xmllvl == 1)
{
xmllvl++;
//printf("<source href='%s'>\n", filename);
}
zbar_process_image(processor, zimage);
// output result data
const zbar_symbol_t *sym = zbar_image_first_symbol(zimage);
for(; sym; sym = zbar_symbol_next(sym))
{
zbar_symbol_type_t typ = zbar_symbol_get_type(sym);
if(typ == ZBAR_PARTIAL)
continue;
else if(!xmllvl)
printf("%s%s:%s\n",
zbar_get_symbol_name(typ),
zbar_get_addon_name(typ),
zbar_symbol_get_data(sym));
else if(xmllvl < 0)
printf("%s\n", zbar_symbol_get_data(sym));
else {
if(xmllvl < 3)
{
xmllvl++;
//printf("<index num='%u'>\n", seq);
}
zbar_symbol_xml(sym, &xmlbuf, &xmlbuflen);
printf("%s\n", xmlbuf);
}
found++;
num_symbols++;
}
if(xmllvl > 2)
{
xmllvl--;
printf("</index>\n");
}
fflush(stdout);
zbar_image_destroy(zimage);
num_images++;
if(zbar_processor_is_visible(processor))
{
printf("waiting for q\n");
int rc = zbar_processor_user_wait(processor, -1);
if(rc < 0 || rc == 'q' || rc == 'Q')
exit_code = 3;
}
//}
if(xmllvl > 1)
{
xmllvl--;
printf("</source>\n");
}
if(!found)
notfound++;
//DestroyMagickWand(images);
return(0);
}//scan_image
static int scan_image (const char *filename)
{
if(exit_code == 3)
return(-1);
int found = 0;
MagickWand *images = NewMagickWand();
if(!MagickReadImage(images, filename) && dump_error(images))
return(-1);
unsigned seq, n = MagickGetNumberImages(images);
for(seq = 0; seq < n; seq++) {
if(exit_code == 3)
return(-1);
if(!MagickSetIteratorIndex(images, seq) && dump_error(images))
return(-1);
zbar_image_t *zimage = zbar_image_create();
assert(zimage);
zbar_image_set_format(zimage, *(unsigned long*)"Y800");
int width = MagickGetImageWidth(images);
int height = MagickGetImageHeight(images);
zbar_image_set_size(zimage, width, height);
// extract grayscale image pixels
// FIXME color!! ...preserve most color w/422P
// (but only if it's a color image)
size_t bloblen = width * height;
unsigned char *blob = malloc(bloblen);
zbar_image_set_data(zimage, blob, bloblen, zbar_image_free_data);
if(!MagickExportImagePixels(images, 0, 0, width, height,
"I", CharPixel, blob))
return(-1);
if(xmllvl == 1) {
xmllvl++;
printf("<source href='%s'>\n", filename);
}
zbar_process_image(processor, zimage);
// output result data
const zbar_symbol_t *sym = zbar_image_first_symbol(zimage);
for(; sym; sym = zbar_symbol_next(sym)) {
zbar_symbol_type_t typ = zbar_symbol_get_type(sym);
if(typ == ZBAR_PARTIAL)
continue;
else if(!xmllvl)
printf("%s%s:%s\n",
zbar_get_symbol_name(typ),
zbar_get_addon_name(typ),
zbar_symbol_get_data(sym));
else if(xmllvl < 0)
printf("%s\n", zbar_symbol_get_data(sym));
else {
if(xmllvl < 3) {
xmllvl++;
printf("<index num='%u'>\n", seq);
}
zbar_symbol_xml(sym, &xmlbuf, &xmlbuflen);
printf("%s\n", xmlbuf);
}
found++;
num_symbols++;
}
if(xmllvl > 2) {
xmllvl--;
printf("</index>\n");
}
fflush(stdout);
zbar_image_destroy(zimage);
num_images++;
if(zbar_processor_is_visible(processor)) {
int rc = zbar_processor_user_wait(processor, -1);
if(rc < 0 || rc == 'q' || rc == 'Q')
exit_code = 3;
}
}
if(xmllvl > 1) {
xmllvl--;
printf("</source>\n");
}
if(!found)
notfound++;
DestroyMagickWand(images);
return(0);
}
/* 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"));
}
