A GTK3 camera application that knows how to deal with the media request api
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
megapixels/src/zbar_pipeline.c

263 lines
5.7 KiB

#include "zbar_pipeline.h"
#include "pipeline.h"
#include "main.h"
#include "io_pipeline.h"
#include <zbar.h>
#include <assert.h>
struct _MPZBarImage {
uint8_t *data;
MPPixelFormat pixel_format;
int width;
int height;
int rotation;
bool mirrored;
_Atomic int ref_count;
};
static MPPipeline *pipeline;
static volatile int frames_processed = 0;
static volatile int frames_received = 0;
static zbar_image_scanner_t *scanner;
static void setup(MPPipeline *pipeline, const void *data)
{
scanner = zbar_image_scanner_create();
zbar_image_scanner_set_config(scanner, 0, ZBAR_CFG_ENABLE, 1);
}
void
mp_zbar_pipeline_start()
{
pipeline = mp_pipeline_new();
mp_pipeline_invoke(pipeline, setup, NULL, 0);
}
void
mp_zbar_pipeline_stop()
{
mp_pipeline_free(pipeline);
}
static bool
is_3d_code(zbar_symbol_type_t type)
{
switch (type) {
case ZBAR_EAN2:
case ZBAR_EAN5:
case ZBAR_EAN8:
case ZBAR_UPCE:
case ZBAR_ISBN10:
case ZBAR_UPCA:
case ZBAR_EAN13:
case ZBAR_ISBN13:
case ZBAR_I25:
case ZBAR_DATABAR:
case ZBAR_DATABAR_EXP:
case ZBAR_CODABAR:
case ZBAR_CODE39:
case ZBAR_CODE93:
case ZBAR_CODE128:
return false;
case ZBAR_COMPOSITE:
case ZBAR_PDF417:
case ZBAR_QRCODE:
case ZBAR_SQCODE:
return true;
default:
return false;
}
}
static inline void
map_coords(int *x, int *y, int width, int height, int rotation, bool mirrored)
{
int x_r, y_r;
if (rotation == 0) {
x_r = *x;
y_r = *y;
} else if (rotation == 90) {
x_r = *y;
y_r = height - *x - 1;
} else if (rotation == 270) {
x_r = width - *y - 1;
y_r = *x;
} else {
x_r = width - *x - 1;
y_r = height - *y - 1;
}
if (mirrored) {
x_r = width - x_r - 1;
}
*x = x_r;
*y = y_r;
}
static MPZBarCode
process_symbol(const MPZBarImage *image, int width, int height, const zbar_symbol_t *symbol)
{
if (image->rotation == 90 || image->rotation == 270) {
int tmp = width;
width = height;
height = tmp;
}
MPZBarCode code;
unsigned loc_size = zbar_symbol_get_loc_size(symbol);
assert(loc_size > 0);
zbar_symbol_type_t type = zbar_symbol_get_type(symbol);
if (is_3d_code(type) && loc_size == 4) {
for (unsigned i = 0; i < loc_size; ++i) {
code.bounds_x[i] = zbar_symbol_get_loc_x(symbol, i);
code.bounds_y[i] = zbar_symbol_get_loc_y(symbol, i);
}
} else {
int min_x = zbar_symbol_get_loc_x(symbol, 0);
int min_y = zbar_symbol_get_loc_y(symbol, 0);
int max_x = min_x, max_y = min_y;
for (unsigned i = 1; i < loc_size; ++i) {
int x = zbar_symbol_get_loc_x(symbol, i);
int y = zbar_symbol_get_loc_y(symbol, i);
min_x = MIN(min_x, x);
min_y = MIN(min_y, y);
max_x = MAX(max_x, x);
max_y = MAX(max_y, y);
}
code.bounds_x[0] = min_x;
code.bounds_y[0] = min_y;
code.bounds_x[1] = max_x;
code.bounds_y[1] = min_y;
code.bounds_x[2] = max_x;
code.bounds_y[2] = max_y;
code.bounds_x[3] = min_x;
code.bounds_y[3] = max_y;
}
for (uint8_t i = 0; i < 4; ++i) {
map_coords(&code.bounds_x[i], &code.bounds_y[i], width, height, image->rotation, image->mirrored);
}
const char *data = zbar_symbol_get_data(symbol);
unsigned int data_size = zbar_symbol_get_data_length(symbol);
code.type = zbar_get_symbol_name(type);
code.data = strndup(data, data_size+1);
code.data[data_size] = 0;
return code;
}
static void
process_image(MPPipeline *pipeline, MPZBarImage **_image)
{
MPZBarImage *image = *_image;
assert(image->pixel_format == MP_PIXEL_FMT_BGGR8
|| image->pixel_format == MP_PIXEL_FMT_GBRG8
|| image->pixel_format == MP_PIXEL_FMT_GRBG8
|| image->pixel_format == MP_PIXEL_FMT_RGGB8);
// Create a grayscale image for scanning from the current preview.
// Rotate/mirror correctly.
int width = image->width / 2;
int height = image->height / 2;
uint8_t *data = malloc(width * height * sizeof(uint8_t));
size_t i = 0;
for (int y = 0; y < image->height; y += 2) {
for (int x = 0; x < image->width; x += 2) {
data[++i] = image->data[x + image->width * y];
}
}
// Create image for zbar
zbar_image_t *zbar_image = zbar_image_create();
zbar_image_set_format(zbar_image, zbar_fourcc('Y', '8', '0', '0'));
zbar_image_set_size(zbar_image, width, height);
zbar_image_set_data(zbar_image, data, width * height * sizeof(uint8_t), zbar_image_free_data);
int res = zbar_scan_image(scanner, zbar_image);
assert(res >= 0);
if (res > 0) {
MPZBarScanResult *result = malloc(sizeof(MPZBarScanResult));
result->size = res;
const zbar_symbol_t *symbol = zbar_image_first_symbol(zbar_image);
for (int i = 0; i < MIN(res, 8); ++i) {
assert(symbol != NULL);
result->codes[i] = process_symbol(image, width, height, symbol);
symbol = zbar_symbol_next(symbol);
}
mp_main_set_zbar_result(result);
} else {
mp_main_set_zbar_result(NULL);
}
zbar_image_destroy(zbar_image);
mp_zbar_image_unref(image);
++frames_processed;
}
void
mp_zbar_pipeline_process_image(MPZBarImage *image)
{
// If we haven't processed the previous frame yet, drop this one
if (frames_received != frames_processed) {
mp_zbar_image_unref(image);
return;
}
++frames_received;
mp_pipeline_invoke(pipeline, (MPPipelineCallback)process_image, &image,
sizeof(MPZBarImage *));
}
MPZBarImage *
mp_zbar_image_new(uint8_t *data,
MPPixelFormat pixel_format,
int width,
int height,
int rotation,
bool mirrored)
{
MPZBarImage *image = malloc(sizeof(MPZBarImage));
image->data = data;
image->pixel_format = pixel_format;
image->width = width;
image->height = height;
image->rotation = rotation;
image->mirrored = mirrored;
image->ref_count = 1;
return image;
}
MPZBarImage *
mp_zbar_image_ref(MPZBarImage *image)
{
++image->ref_count;
return image;
}
void
mp_zbar_image_unref(MPZBarImage *image)
{
if (--image->ref_count == 0) {
free(image->data);
free(image);
}
}