259 lines
8.4 KiB
C
259 lines
8.4 KiB
C
#include "raster_tools.h"
|
|
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "qrcodegen.h"
|
|
|
|
#define RASTER_WIDTH 384
|
|
#define RASTER_BYTES_PER_ROW (RASTER_WIDTH / 8)
|
|
|
|
static void set_black(uint8_t *buf, uint16_t width, uint16_t x, uint16_t y) {
|
|
if (x >= width) {
|
|
return;
|
|
}
|
|
uint16_t bpr = width / 8;
|
|
size_t idx = (size_t)y * bpr + (x / 8);
|
|
uint8_t bit = (uint8_t)(7 - (x % 8));
|
|
buf[idx] |= (uint8_t)(1u << bit);
|
|
}
|
|
|
|
esp_err_t raster_tools_convert_gray8_to_raster_384(const uint8_t *gray,
|
|
uint16_t src_width,
|
|
uint16_t src_height,
|
|
bool scale_to_width,
|
|
uint8_t threshold,
|
|
bool invert,
|
|
uint16_t max_height,
|
|
uint16_t *out_width,
|
|
uint16_t *out_height,
|
|
uint8_t **out_raster,
|
|
size_t *out_len,
|
|
char *err,
|
|
size_t err_len) {
|
|
if (gray == NULL || src_width == 0 || src_height == 0 ||
|
|
out_width == NULL || out_height == NULL || out_raster == NULL || out_len == NULL) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid args");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (max_height == 0 || max_height > 3000) {
|
|
max_height = 3000;
|
|
}
|
|
|
|
uint16_t dst_width = RASTER_WIDTH;
|
|
uint16_t dst_height = src_height;
|
|
if (scale_to_width) {
|
|
if (src_width == 0) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid source width");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
uint32_t scaled = ((uint32_t)src_height * RASTER_WIDTH + (src_width / 2u)) / src_width;
|
|
if (scaled == 0) {
|
|
scaled = 1;
|
|
}
|
|
if (scaled > max_height) {
|
|
scaled = max_height;
|
|
}
|
|
dst_height = (uint16_t)scaled;
|
|
} else if (src_width != RASTER_WIDTH) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "width must be 384 when scale_to_width=false");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (dst_height == 0 || dst_height > max_height) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid output height");
|
|
}
|
|
return ESP_ERR_INVALID_SIZE;
|
|
}
|
|
|
|
size_t len = (size_t)RASTER_BYTES_PER_ROW * dst_height;
|
|
uint8_t *raster = (uint8_t *)calloc(1, len);
|
|
if (raster == NULL) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "no memory");
|
|
}
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
for (uint16_t y = 0; y < dst_height; ++y) {
|
|
uint16_t src_y = scale_to_width
|
|
? (uint16_t)(((uint32_t)y * src_height) / dst_height)
|
|
: y;
|
|
if (src_y >= src_height) {
|
|
src_y = (uint16_t)(src_height - 1);
|
|
}
|
|
|
|
for (uint16_t x = 0; x < RASTER_WIDTH; ++x) {
|
|
uint16_t src_x = scale_to_width
|
|
? (uint16_t)(((uint32_t)x * src_width) / RASTER_WIDTH)
|
|
: x;
|
|
if (src_x >= src_width) {
|
|
src_x = (uint16_t)(src_width - 1);
|
|
}
|
|
|
|
uint8_t v = gray[(size_t)src_y * src_width + src_x];
|
|
bool black = invert ? (v > threshold) : (v < threshold);
|
|
if (black) {
|
|
set_black(raster, RASTER_WIDTH, x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
*out_width = dst_width;
|
|
*out_height = dst_height;
|
|
*out_raster = raster;
|
|
*out_len = len;
|
|
return ESP_OK;
|
|
}
|
|
|
|
static enum qrcodegen_Ecc map_qr_ecc(uint8_t ecc_level) {
|
|
switch (ecc_level) {
|
|
case 0:
|
|
return qrcodegen_Ecc_LOW;
|
|
case 1:
|
|
return qrcodegen_Ecc_MEDIUM;
|
|
case 2:
|
|
return qrcodegen_Ecc_QUARTILE;
|
|
case 3:
|
|
default:
|
|
return qrcodegen_Ecc_HIGH;
|
|
}
|
|
}
|
|
|
|
esp_err_t raster_tools_render_qr_384(const char *text,
|
|
uint8_t module_scale,
|
|
uint8_t margin_modules,
|
|
uint8_t ecc_level,
|
|
uint16_t max_height,
|
|
uint16_t *out_width,
|
|
uint16_t *out_height,
|
|
uint8_t **out_raster,
|
|
size_t *out_len,
|
|
char *err,
|
|
size_t err_len) {
|
|
if (text == NULL || text[0] == '\0' ||
|
|
out_width == NULL || out_height == NULL || out_raster == NULL || out_len == NULL) {
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "invalid args");
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if (max_height == 0 || max_height > 3000) {
|
|
max_height = 3000;
|
|
}
|
|
|
|
if (margin_modules == 0) {
|
|
margin_modules = 2;
|
|
}
|
|
|
|
size_t qr_buf_len = qrcodegen_BUFFER_LEN_MAX;
|
|
uint8_t *temp = (uint8_t *)malloc(qr_buf_len);
|
|
uint8_t *qr = (uint8_t *)malloc(qr_buf_len);
|
|
if (temp == NULL || qr == NULL) {
|
|
free(temp);
|
|
free(qr);
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "no memory");
|
|
}
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
bool ok = qrcodegen_encodeText(text,
|
|
temp,
|
|
qr,
|
|
map_qr_ecc(ecc_level),
|
|
qrcodegen_VERSION_MIN,
|
|
qrcodegen_VERSION_MAX,
|
|
qrcodegen_Mask_AUTO,
|
|
true);
|
|
if (!ok) {
|
|
free(temp);
|
|
free(qr);
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "qr encode failed");
|
|
}
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
int qr_size = qrcodegen_getSize(qr);
|
|
int full_modules = qr_size + 2 * margin_modules;
|
|
|
|
if (module_scale == 0) {
|
|
module_scale = (uint8_t)(RASTER_WIDTH / full_modules);
|
|
if (module_scale == 0) {
|
|
module_scale = 1;
|
|
}
|
|
}
|
|
|
|
uint32_t image_size = (uint32_t)full_modules * module_scale;
|
|
if (image_size > RASTER_WIDTH || image_size > max_height) {
|
|
free(temp);
|
|
free(qr);
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "qr too large for 384 width");
|
|
}
|
|
return ESP_ERR_INVALID_SIZE;
|
|
}
|
|
|
|
uint16_t out_h = (uint16_t)image_size;
|
|
size_t len = (size_t)RASTER_BYTES_PER_ROW * out_h;
|
|
uint8_t *raster = (uint8_t *)calloc(1, len);
|
|
if (raster == NULL) {
|
|
free(temp);
|
|
free(qr);
|
|
if (err != NULL && err_len > 0) {
|
|
snprintf(err, err_len, "no memory");
|
|
}
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
uint16_t x_origin = (uint16_t)((RASTER_WIDTH - image_size) / 2);
|
|
for (int my = 0; my < full_modules; ++my) {
|
|
for (int mx = 0; mx < full_modules; ++mx) {
|
|
int qx = mx - margin_modules;
|
|
int qy = my - margin_modules;
|
|
bool black = (qx >= 0 && qx < qr_size && qy >= 0 && qy < qr_size)
|
|
? qrcodegen_getModule(qr, qx, qy)
|
|
: false;
|
|
if (!black) {
|
|
continue;
|
|
}
|
|
|
|
uint16_t px0 = (uint16_t)(x_origin + mx * module_scale);
|
|
uint16_t py0 = (uint16_t)(my * module_scale);
|
|
for (uint8_t sy = 0; sy < module_scale; ++sy) {
|
|
uint16_t py = (uint16_t)(py0 + sy);
|
|
if (py >= out_h) {
|
|
continue;
|
|
}
|
|
for (uint8_t sx = 0; sx < module_scale; ++sx) {
|
|
uint16_t px = (uint16_t)(px0 + sx);
|
|
if (px < RASTER_WIDTH) {
|
|
set_black(raster, RASTER_WIDTH, px, py);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(temp);
|
|
free(qr);
|
|
|
|
*out_width = RASTER_WIDTH;
|
|
*out_height = out_h;
|
|
*out_raster = raster;
|
|
*out_len = len;
|
|
return ESP_OK;
|
|
}
|