int zbar_video_init (zbar_video_t *vdo, unsigned long fmt) { if(vdo->initialized) /* FIXME re-init different format? */ return(err_capture(vdo, SEV_ERROR, ZBAR_ERR_INVALID, __func__, "already initialized, re-init unimplemented")); if(vdo->init(vdo, fmt)) return(-1); vdo->format = fmt; if(video_init_images(vdo)) return(-1); #ifdef HAVE_LIBJPEG const zbar_format_def_t *vidfmt = _zbar_format_lookup(fmt); if(vidfmt && vidfmt->group == ZBAR_FMT_JPEG) { /* prepare for decoding */ if(!vdo->jpeg) vdo->jpeg = _zbar_jpeg_decomp_create(); if(vdo->jpeg_img) zbar_image_destroy(vdo->jpeg_img); /* create intermediate image for decoder to use*/ zbar_image_t *img = vdo->jpeg_img = zbar_image_create(); img->format = fourcc('Y','8','0','0'); img->width = vdo->width; img->height = vdo->height; img->datalen = vdo->width * vdo->height; } #endif vdo->initialized = 1; return(0); }
const char* rho_barcode_barcode_recognize(const char* filename) { void* img_buf = 0; int img_width; int img_height; rho_platform_image_load_grayscale(filename, &img_buf, &img_width, &img_height); if (img_buf != 0) { zbar_image_scanner_t* zbar_img_scanner = zbar_image_scanner_create(); zbar_image_t* zbar_img = zbar_image_create(); const zbar_symbol_t* zbar_symbol = 0; zbar_image_scanner_set_config(zbar_img_scanner, ZBAR_NONE, ZBAR_CFG_ENABLE, 1); zbar_image_set_format(zbar_img, zbar_fourcc('Y','8','0','0')); zbar_image_set_size(zbar_img, img_width, img_height); //zbar_image_set_data(zbar_img, img_buf, img_width * img_height, zbar_image_free_data); zbar_image_set_data(zbar_img, img_buf, img_width * img_height, 0); zbar_scan_image(zbar_img_scanner, zbar_img); // get result //zbar_symbol_set_t* zbar_symbols = zbar_image_get_symbols(zbar_img); zbar_symbol = zbar_image_first_symbol(zbar_img); if (zbar_symbol != 0) { //printf(zbar_symbol_get_data(zbar_symbol)); //sprintf(strbuf, "IMG [%d x %d ]\nCODE = %s",img_width, img_height, zbar_symbol_get_data(zbar_symbol)); strcpy(strbuf, zbar_symbol_get_data(zbar_symbol)); } else { //sprintf(strbuf, "IMG [%d x %d ]\nCODE IS UNRECOGNIZED ",img_width, img_height); strcpy(strbuf, ""); } zbar_image_destroy(zbar_img); zbar_image_scanner_destroy(zbar_img_scanner); } else { //sprintf(strbuf, "NO IMG TO RECOGNIZE",img_width, img_height); strcpy(strbuf, ""); } if (img_buf) { rho_platform_image_free(img_buf); } return strbuf; }
JNIEXPORT jstring JNICALL Java_com_acdd_qrcode_BarCode_decodeCrop( JNIEnv *env,jclass clazz, jbyteArray img, jint width, jint height, jint x, jint y, jint cropw, jint croph) { zbar_image_scanner_t *scanner; zbar_image_t *zimage; zbar_image_t *zgrayimage; jbyte *pixbuf; jstring s = NULL; zbar_set_verbosity(10); // XXX pixbuf = (*env)->GetByteArrayElements(env, img, 0); zimage = zbar_image_create(); if (zimage == NULL) { (*env)->ReleaseByteArrayElements(env, img, pixbuf, 0); return NULL; } zbar_image_set_format(zimage, *(unsigned long *) "Y800"); zbar_image_set_size(zimage, width, height); zbar_image_set_data(zimage, pixbuf, (*env)->GetArrayLength(env, img), zbar_image_free_data); zbar_image_set_crop(zimage, x, y, cropw, croph); zgrayimage = zbar_image_convert(zimage, *(unsigned long *) "Y800"); if (zgrayimage == NULL) { (*env)->ReleaseByteArrayElements(env, img, pixbuf, 0); return NULL; } zbar_image_destroy(zimage); scanner = zbar_image_scanner_create(); zbar_image_scanner_set_config(scanner, 0, ZBAR_CFG_ENABLE, 1); zbar_scan_image(scanner, zgrayimage); const zbar_symbol_t *sym; sym = zbar_image_first_symbol(zgrayimage); if (sym != NULL) { const char *sym_data; sym_data = zbar_symbol_get_data(sym); __android_log_print(ANDROID_LOG_DEBUG, "zbar", "url: %s", sym_data); s = (*env)->NewStringUTF(env, sym_data); } (*env)->ReleaseByteArrayElements(env, img, pixbuf, 0); return s; }
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); }
JNIEXPORT jstring JNICALL Java_trikita_obsqr_Zbar_process (JNIEnv *env, jobject obj, jint w, jint h, jbyteArray img) { zbar_image_scanner_t *scanner; zbar_image_t *zimage; zbar_image_t *zgrayimage; jbyte *pixbuf; jstring s = NULL; zbar_set_verbosity(10); // XXX pixbuf = (*env)->GetByteArrayElements(env, img, 0); zimage = zbar_image_create(); if (zimage == NULL) { (*env)->ReleaseByteArrayElements(env, img, pixbuf, 0); return NULL; } zbar_image_set_format(zimage, *(unsigned long *) "Y800"); zbar_image_set_size(zimage, w, h); zbar_image_set_data(zimage, pixbuf, (*env)->GetArrayLength(env, img), zbar_image_free_data); zgrayimage = zbar_image_convert(zimage, *(unsigned long *) "Y800"); if (zgrayimage == NULL) { (*env)->ReleaseByteArrayElements(env, img, pixbuf, 0); return NULL; } zbar_image_destroy(zimage); scanner = zbar_image_scanner_create(); zbar_image_scanner_set_config(scanner, 0, ZBAR_CFG_ENABLE, 1); zbar_scan_image(scanner, zgrayimage); const zbar_symbol_t *sym; sym = zbar_image_first_symbol(zgrayimage); if (sym != NULL) { const char *sym_data; sym_data = zbar_symbol_get_data(sym); __android_log_print(ANDROID_LOG_DEBUG, "zbar", "url: %s", sym_data); s = (*env)->NewStringUTF(env, sym_data); } (*env)->ReleaseByteArrayElements(env, img, pixbuf, 0); return s; }
bool BarcodeScanner::getBarcode(char* barcodeType, char* barcode) { if(mImageScanner == NULL) maPanic(0, "No Image Scanner"); if(mImage == NULL) maPanic(0, "No Image Data!"); // scan the image for barcodes int n = zbar_scan_image(mImageScanner, mImage); // extract results const zbar::zbar_symbol_t *symbol = zbar_image_first_symbol(mImage); bool result = false; for(; symbol; symbol = zbar_symbol_next(symbol)) { // do something useful with results zbar::zbar_symbol_type_t typ = zbar_symbol_get_type(symbol); //sprintf(barcode, "%s\n%s", // getBarcodeType((int)zbar_symbol_get_type(symbol)), // zbar_symbol_get_data(symbol) ); const char *type = getBarcodeType((int)typ); const char *data = zbar_symbol_get_data(symbol); if((type == NULL) || (data == NULL)) break; result = true; sprintf(barcodeType, "%s", type); sprintf(barcode, "%s", data); //printf("decoded %s symbol \"%s\"\n", // zbar_get_symbol_name(typ), data); } // clean up zbar_image_destroy(mImage); free(mImgData); mImage = NULL; mImgData = NULL; return result; }
static ZTHREAD proc_video_thread (void *arg) { zbar_processor_t *proc = arg; zbar_thread_t *thread = &proc->video_thread; _zbar_mutex_lock(&proc->mutex); _zbar_thread_init(thread); zprintf(4, "spawned video thread\n"); while(thread->started) { /* wait for video stream to be active */ while(thread->started && !proc->streaming) _zbar_event_wait(&thread->notify, &proc->mutex, NULL); if(!thread->started) break; /* blocking capture image from video */ _zbar_mutex_unlock(&proc->mutex); zbar_image_t *img = zbar_video_next_image(proc->video); _zbar_mutex_lock(&proc->mutex); if(!img && !proc->streaming) continue; else if(!img) /* FIXME could abort streaming and keep running? */ break; /* acquire API lock */ _zbar_processor_lock(proc); _zbar_mutex_unlock(&proc->mutex); if(thread->started && proc->streaming) _zbar_process_image(proc, img); zbar_image_destroy(img); _zbar_mutex_lock(&proc->mutex); /* release API lock */ _zbar_processor_unlock(proc, 0); } thread->running = 0; _zbar_event_trigger(&thread->activity); _zbar_mutex_unlock(&proc->mutex); return(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 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); }
int main (int argc, char **argv) { if(argc < 2) return(1); /* create a reader */ scanner = zbar_image_scanner_create(); /* configure the reader */ zbar_image_scanner_set_config(scanner, 0, ZBAR_CFG_ENABLE, 1); /* obtain image data */ int width = 1920, height = 1080; void *raw = NULL; get_yuv_data(argv[1], &width, &height, &raw); /* wrap image data */ zbar_image_t *image = zbar_image_create(); zbar_image_set_format(image, *(int*)"Y800"); zbar_image_set_size(image, width, height); zbar_image_set_data(image, raw, width * height, zbar_image_free_data); /* scan the image for barcodes */ int n = zbar_scan_image(scanner, image); if(0==n||-1==n) { printf("no symbols were found or -1 if an error occurs\n"); } /* extract results */ const zbar_symbol_t *symbol = zbar_image_first_symbol(image); for(; symbol; symbol = zbar_symbol_next(symbol)) { /* do something useful with results */ zbar_symbol_type_t typ = zbar_symbol_get_type(symbol); const char *data = zbar_symbol_get_data(symbol); printf("decoded %s symbol \"%s\"\n", zbar_get_symbol_name(typ), data); } /* clean up */ zbar_image_destroy(image); zbar_image_scanner_destroy(scanner); return(0); }
void zbar_video_destroy (zbar_video_t *vdo) { if(vdo->intf != VIDEO_INVALID) zbar_video_open(vdo, NULL); if(vdo->images) { int i; for(i = 0; i < ZBAR_VIDEO_IMAGES_MAX; i++) if(vdo->images[i]) _zbar_image_free(vdo->images[i]); free(vdo->images); } while(vdo->shadow_image) { zbar_image_t *img = vdo->shadow_image; vdo->shadow_image = img->next; free((void*)img->data); img->data = NULL; free(img); } if(vdo->buf) free(vdo->buf); if(vdo->formats) free(vdo->formats); err_cleanup(&vdo->err); _zbar_mutex_destroy(&vdo->qlock); #ifdef HAVE_LIBJPEG if(vdo->jpeg_img) { zbar_image_destroy(vdo->jpeg_img); vdo->jpeg_img = NULL; } if(vdo->jpeg) { _zbar_jpeg_decomp_destroy(vdo->jpeg); vdo->jpeg = NULL; } #endif free(vdo); }
int c_zbar(IMG(x), int*m, TBarcode* result) { //printf("hello\n"); /* create a reader */ zbar_image_scanner_t * scanner = zbar_image_scanner_create(); /* configure the reader */ zbar_image_scanner_set_config(scanner, 0, ZBAR_CFG_ENABLE, 1); /* obtain image data */ int width = xsc2+1, height = xsr2+1; if (xsc1!=0 || xsr1!=0 || xsstep != width) { printf("c1=%d c2=%d r1=%d r2=%d step=%d\n",xsc1,xsc2,xsr1,xsr2,xsstep); return 1; } void *raw = xpSrc; //get_data(argv[1], &width, &height, &raw); /* wrap image data */ zbar_image_t *image = zbar_image_create(); zbar_image_set_format(image, *(int*)"Y800"); zbar_image_set_size(image, width, height); zbar_image_set_data(image, raw, width * height, NULL); //printf("after set\n"); /* scan the image for barcodes */ int n = zbar_scan_image(scanner, image); //printf("scan_image code: %d\n",n); /* extract results */ int k = 0; const zbar_symbol_t *symbol = zbar_image_first_symbol(image); for(; symbol; symbol = zbar_symbol_next(symbol)) { /* do something useful with results */ zbar_symbol_type_t typ = zbar_symbol_get_type(symbol); result[k].symbol_type = zbar_get_symbol_name(typ); const char *data = zbar_symbol_get_data(symbol); result[k].symbol_value = data; // printf("decoded %s symbol \"%s\"\n",zbar_get_symbol_name(typ), data); int np = zbar_symbol_get_loc_size(symbol); //printf("np=%d\n",np); int j,x,y,r1,c1,r2,c2; c1 = c2 = zbar_symbol_get_loc_x(symbol,0); r1 = r2 = zbar_symbol_get_loc_y(symbol,0); for (j=1; j<np; j++) { x = zbar_symbol_get_loc_x(symbol,j); y = zbar_symbol_get_loc_y(symbol,j); if (y<r1) r1 = y; if (y>r2) r2 = y; if (x<c1) c1 = x; if (x>c2) c2 = x; //printf("j=%d\n",j); } result[k].bbr1 = r1; result[k].bbr2 = r2; result[k].bbc1 = c1; result[k].bbc2 = c2; k++; if(k>=50) break; } /* clean up */ zbar_image_destroy(image); *m = k; return n; }
static void *zbar_gtk_processing_thread (void *arg) { ZBarGtk *self = ZBAR_GTK(arg); if(!self->_private) return(NULL); ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private); g_object_ref(zbar); g_assert(zbar->queue); g_async_queue_ref(zbar->queue); zbar->scanner = zbar_image_scanner_create(); g_assert(zbar->scanner); /* thread side enabled state */ gboolean video_enabled = FALSE; GValue *msg = NULL; while(TRUE) { if(!msg) msg = g_async_queue_pop(zbar->queue); g_assert(G_IS_VALUE(msg)); GType type = G_VALUE_TYPE(msg); if(type == G_TYPE_INT) { /* video state change */ int state = g_value_get_int(msg); if(state < 0) { /* terminate processing thread */ g_value_unset(msg); g_free(msg); msg = NULL; break; } g_assert(state >= 0 && state <= 1); video_enabled = (state != 0); } else if(type == G_TYPE_STRING) { /* open new video device */ const char *video_device = g_value_get_string(msg); video_enabled = zbar_gtk_video_open(self, video_device); } else if(type == GDK_TYPE_PIXBUF) { /* scan provided image and broadcast results */ zbar_image_t *image = zbar_image_create(); GdkPixbuf *pixbuf = GDK_PIXBUF(g_value_dup_object(msg)); if(zbar_gtk_image_from_pixbuf(image, pixbuf)) zbar_gtk_process_image(self, image); else g_object_unref(pixbuf); zbar_image_destroy(image); } else { gchar *dbg = g_strdup_value_contents(msg); g_warning("unknown message type (%x) passed to thread: %s\n", (unsigned)type, dbg); g_free(dbg); } g_value_unset(msg); g_free(msg); msg = NULL; if(video_enabled) { /* release reference to any previous pixbuf */ zbar_window_draw(zbar->window, NULL); if(zbar_video_enable(zbar->video, 1)) { zbar_video_error_spew(zbar->video, 0); video_enabled = FALSE; continue; } zbar_image_scanner_enable_cache(zbar->scanner, 1); while(video_enabled && !(msg = g_async_queue_try_pop(zbar->queue))) { zbar_image_t *image = zbar_video_next_image(zbar->video); if(zbar_gtk_process_image(self, image) < 0) video_enabled = FALSE; if(image) zbar_image_destroy(image); } zbar_image_scanner_enable_cache(zbar->scanner, 0); if(zbar_video_enable(zbar->video, 0)) { zbar_video_error_spew(zbar->video, 0); video_enabled = FALSE; } /* release video image and revert to logo */ if(zbar->window) { zbar_window_draw(zbar->window, NULL); gtk_widget_queue_draw(GTK_WIDGET(self)); } if(!video_enabled) /* must have been an error while streaming */ zbar_gtk_video_open(self, NULL); } } if(zbar->window) zbar_window_draw(zbar->window, NULL); g_object_unref(zbar); return(NULL); }
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, zbar_fourcc('Y','8','0','0')); 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); unsigned len = zbar_symbol_get_data_length(sym); if(typ == ZBAR_PARTIAL) continue; else if(xmllvl <= 0) { if(!xmllvl) printf("%s:", zbar_get_symbol_name(typ)); if(len && fwrite(zbar_symbol_get_data(sym), len, 1, stdout) != 1) { exit_code = 1; return(-1); } } else { if(xmllvl < 3) { xmllvl++; printf("<index num='%u'>\n", seq); } zbar_symbol_xml(sym, &xmlbuf, &xmlbuflen); if(fwrite(xmlbuf, xmlbuflen, 1, stdout) != 1) { exit_code = 1; return(-1); } } printf("\n"); 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")); }
/** * Entry point of the program. The MAMain function * needs to be declared as extern "C". */ extern "C" int MAMain() { MAEvent event; int imgSize = maGetImageSize(RES_BARCODE_IMAGE); int imgW = EXTENT_X(imgSize); int imgH = EXTENT_Y(imgSize); int imgDataSize = imgW * imgH; int* imgData = (int*) malloc(imgDataSize * 4); MARect imgRect; imgRect.left = 0; imgRect.top = 0; imgRect.width = imgW; imgRect.height = imgH; maGetImageData(RES_BARCODE_IMAGE, imgData, &imgRect, imgW); unsigned char* fixedImg = (unsigned char*) malloc(imgDataSize); printf("Converting image\n"); createLuminosity(imgData, fixedImg, imgDataSize); printf("Scanning for barcodes\n"); // create a reader zbar::ImageScanner scanner = zbar::zbar_image_scanner_create(); // configure the reader zbar::zbar_image_scanner_set_config(scanner, zbar::ZBAR_NONE, zbar::ZBAR_CFG_ENABLE, 1); // wrap image data zbar::zbar_image_t *image = zbar::zbar_image_create(); zbar::zbar_image_set_format(image, 0x30303859);// "Y800" = 0x30303859 zbar::zbar_image_set_size(image, imgW, imgH); zbar::zbar_image_set_data(image, fixedImg, imgW * imgH, NULL);//zbar_image_free_data); // scan the image for barcodes zbar_scan_image(scanner, image); // extract results bool result = false; const zbar::zbar_symbol_t *symbol = zbar_image_first_symbol(image); for(; symbol; symbol = zbar_symbol_next(symbol)) { // do something useful with results zbar::zbar_symbol_type_t typ = zbar_symbol_get_type(symbol); const char *data = zbar_symbol_get_data(symbol); printf("decoded %s symbol \"%s\"\n", zbar_get_symbol_name(typ), data); result = true; } // clean up zbar_image_destroy(image); if(!result) printf("No symbols found.\n"); printf("Press zero, back or touch screen to exit\n"); while (TRUE) { maWait(0); maGetEvent(&event); if (EVENT_TYPE_CLOSE == event.type) { // Exit while loop. break; } else if (EVENT_TYPE_KEY_PRESSED == event.type) { if (MAK_BACK == event.key || MAK_0 == event.key) { // Exit while loop. break; } } else if (EVENT_TYPE_POINTER_PRESSED == event.type) { break; } } return 0; }
inline int zbar_window_redraw (zbar_window_t *w) { if(window_lock(w)) return(-1); if(!w->display || _zbar_window_begin(w)) { (void)window_unlock(w); return(-1); } int rc = 0; zbar_image_t *img = w->image; if(w->init && w->draw_image && img) { int format_change = (w->src_format != img->format && w->format != img->format); if(format_change) { _zbar_best_format(img->format, &w->format, w->formats); if(!w->format) rc = err_capture_int(w, SEV_ERROR, ZBAR_ERR_UNSUPPORTED, __func__, "no conversion from %x to supported formats", img->format); w->src_format = img->format; } if(!rc && (format_change || !w->scaled_size.x || !w->dst_width)) { zprintf(24, "init: src=%.4s(%08lx) %dx%d dst=%.4s(%08lx) %dx%d\n", (char*)&w->src_format, w->src_format, w->src_width, w->src_height, (char*)&w->format, w->format, w->dst_width, w->dst_height); if(!w->dst_width) { w->src_width = img->width; w->src_height = img->height; } point_t size = { w->width, w->height }; if(size.x > w->max_width) size.x = w->max_width; if(size.y > w->max_height) size.y = w->max_height; if(size.x * w->src_height < size.y * w->src_width) { w->scale_num = size.x; w->scale_den = w->src_width; } else { w->scale_num = size.y; w->scale_den = w->src_height; } rc = w->init(w, img, format_change); if(!rc) { size.x = w->src_width; size.y = w->src_height; w->scaled_size = size = window_scale_pt(w, size); w->scaled_offset.x = ((int)w->width - size.x) / 2; w->scaled_offset.y = ((int)w->height - size.y) / 2; zprintf(24, "scale: src=%dx%d win=%dx%d by %d/%d => %dx%d @%d,%d\n", w->src_width, w->src_height, w->width, w->height, w->scale_num, w->scale_den, size.x, size.y, w->scaled_offset.x, w->scaled_offset.y); } else { /* unable to display this image */ _zbar_image_refcnt(img, -1); w->image = img = NULL; } } if(!rc && (img->format != w->format || img->width != w->dst_width || img->height != w->dst_height)) { /* save *converted* image for redraw */ zprintf(48, "convert: %.4s(%08lx) %dx%d => %.4s(%08lx) %dx%d\n", (char*)&img->format, img->format, img->width, img->height, (char*)&w->format, w->format, w->dst_width, w->dst_height); w->image = zbar_image_convert_resize(img, w->format, w->dst_width, w->dst_height); w->image->syms = img->syms; if(img->syms) zbar_symbol_set_ref(img->syms, 1); zbar_image_destroy(img); img = w->image; } if(!rc) { rc = w->draw_image(w, img); point_t org = w->scaled_offset; if(org.x > 0) { point_t p = { 0, org.y }; point_t s = { org.x, w->scaled_size.y }; _zbar_window_fill_rect(w, 0, p, s); s.x = w->width - w->scaled_size.x - s.x; if(s.x > 0) { p.x = w->width - s.x; _zbar_window_fill_rect(w, 0, p, s); } } if(org.y > 0) { point_t p = { 0, 0 }; point_t s = { w->width, org.y }; _zbar_window_fill_rect(w, 0, p, s); s.y = w->height - w->scaled_size.y - s.y; if(s.y > 0) { p.y = w->height - s.y; _zbar_window_fill_rect(w, 0, p, s); } } } if(!rc) rc = window_draw_overlay(w); } else rc = 1; if(rc) rc = _zbar_window_draw_logo(w); _zbar_window_end(w); (void)window_unlock(w); return(rc); }
static GstFlowReturn gst_zbar_transform_frame_ip (GstVideoFilter * vfilter, GstVideoFrame * frame) { GstZBar *zbar = GST_ZBAR (vfilter); gpointer data; gint stride, height; zbar_image_t *image; const zbar_symbol_t *symbol; int n; image = zbar_image_create (); /* all formats we support start with an 8-bit Y plane. zbar doesn't need * to know about the chroma plane(s) */ data = GST_VIDEO_FRAME_COMP_DATA (frame, 0); stride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0); height = GST_VIDEO_FRAME_HEIGHT (frame); zbar_image_set_format (image, GST_MAKE_FOURCC ('Y', '8', '0', '0')); zbar_image_set_size (image, stride, height); zbar_image_set_data (image, (gpointer) data, stride * height, NULL); /* scan the image for barcodes */ n = zbar_scan_image (zbar->scanner, image); if (n == 0) goto out; /* extract results */ symbol = zbar_image_first_symbol (image); for (; symbol; symbol = zbar_symbol_next (symbol)) { zbar_symbol_type_t typ = zbar_symbol_get_type (symbol); const char *data = zbar_symbol_get_data (symbol); gint quality = zbar_symbol_get_quality (symbol); GST_DEBUG_OBJECT (zbar, "decoded %s symbol \"%s\" at quality %d", zbar_get_symbol_name (typ), data, quality); if (zbar->cache && zbar_symbol_get_count (symbol) != 0) continue; if (zbar->message) { GstMessage *m; GstStructure *s; /* post a message */ s = gst_structure_new ("barcode", "timestamp", G_TYPE_UINT64, GST_BUFFER_TIMESTAMP (frame->buffer), "type", G_TYPE_STRING, zbar_get_symbol_name (typ), "symbol", G_TYPE_STRING, data, "quality", G_TYPE_INT, quality, NULL); m = gst_message_new_element (GST_OBJECT (zbar), s); gst_element_post_message (GST_ELEMENT (zbar), m); } } out: /* clean up */ zbar_image_scanner_recycle_image (zbar->scanner, image); zbar_image_destroy (image); return GST_FLOW_OK; }
static GstFlowReturn gst_skor_sink_transform_frame_ip (GstVideoFilter * vfilter, GstVideoFrame * frame) { GstSkorSink *sink = GST_SKORSINK (vfilter); gpointer data; gint stride, height; zbar_image_t *image; const zbar_symbol_t *symbol; int n; image = zbar_image_create (); /* all formats we support start with an 8-bit Y plane. zbar doesn't need * to know about the chroma plane(s) */ data = GST_VIDEO_FRAME_COMP_DATA (frame, 0); stride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0); height = GST_VIDEO_FRAME_HEIGHT (frame); zbar_image_set_format (image, GST_MAKE_FOURCC ('Y', '8', '0', '0')); zbar_image_set_size (image, stride, height); zbar_image_set_data (image, (gpointer) data, stride * height, NULL); /* scan the image for barcodes */ n = zbar_scan_image (sink->scanner, image); if (G_UNLIKELY (n == -1)) { GST_WARNING_OBJECT (sink, "Error trying to scan frame. Skipping"); goto out; } if (n == 0) goto out; /* extract results */ symbol = zbar_image_first_symbol (image); for (; symbol; symbol = zbar_symbol_next (symbol)) { zbar_symbol_type_t typ = zbar_symbol_get_type (symbol); const char *data = zbar_symbol_get_data (symbol); gint quality = zbar_symbol_get_quality (symbol); GST_DEBUG_OBJECT (sink, "decoded %s symbol \"%s\" at quality %d", zbar_get_symbol_name (typ), data, quality); if (sink->cache && zbar_symbol_get_count (symbol) != 0) continue; if (sink->data_consumer) sink->data_consumer (data); if (sink->message) { GstMessage *m; GstStructure *s; GstSample *sample; GstCaps *sample_caps; s = gst_structure_new ("barcode", "timestamp", G_TYPE_UINT64, GST_BUFFER_TIMESTAMP (frame->buffer), "type", G_TYPE_STRING, zbar_get_symbol_name (typ), "symbol", G_TYPE_STRING, data, "quality", G_TYPE_INT, quality, NULL); if (sink->attach_frame) { /* create a sample from image */ sample_caps = gst_video_info_to_caps (&frame->info); sample = gst_sample_new (frame->buffer, sample_caps, NULL, NULL); gst_caps_unref (sample_caps); gst_structure_set (s, "frame", GST_TYPE_SAMPLE, sample, NULL); gst_sample_unref (sample); } m = gst_message_new_element (GST_OBJECT (sink), s); gst_element_post_message (GST_ELEMENT (sink), m); } else if (sink->attach_frame) GST_WARNING_OBJECT (sink, "attach-frame=true has no effect if message=false"); } out: /* clean up */ zbar_image_scanner_recycle_image (sink->scanner, image); zbar_image_destroy (image); return GST_FLOW_OK; }
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
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); }