blurhash_decoder 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68941f08272cb7b00dab2261afc755cd8833f67e3407f75d1eca45a4c765938b
-  data.tar.gz: 7d641afcd4a5ee0366112268f3c7a4d3d8a078c90f478118116a0dc1f9360595
+  metadata.gz: b0221d3511057d149926cc067e2a8e2eb51ff0c724476666e618df955160626e
+  data.tar.gz: a271106fec9b1e3872b0ab1a8ec7753e8b4e68a055887ba0dee57e9bd3964d1e
 SHA512:
-  metadata.gz: b8476b070ae0f36d0f7369998fe8cd672ec92a80f5347c48cf03db2073c12ddad3f6a2f1d5e4df328bb6c79b942a1d604c5f6a68e37bf070973d649680f4be66
-  data.tar.gz: '0813bb02a43ca11415eb9bc087446a5f6bc8a4b5be13d29cb03c6cd248ddd042e322132210dc29f000cce1dd809091af733c3074c32ac2bdf58c9a28a8afead5'
+  metadata.gz: dbbb92c47bcb19a4445e58c1a22ec038642fce18d01209a9b528b70707c42905385164aaf48b9b0b9f2165f7d7a1118ccef7533b2e58e56e37ca862fba8d98a2
+  data.tar.gz: 125ef0207f696e1bf40055e8ffdbd14419b47ce83e0e7efb9bc7dfb79dbe55b685efa04c4d894a55d17a4cd00c010b7e437b2187167a4d6234df454c4c58ea12

data/blurhash_decoder.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification.new do |s|
     s.name        = 'blurhash_decoder'
-    s.version     = '0.0.10'
+    s.version     = '0.0.11'
     s.summary     = "A blurhash decoder gem!"
     s.description = "A simple blurhash decoder gem using c."
     s.authors     = ["Rabin Poudyal"]

data/ext/blurhash_encoder/blurhash_encoder.c

@@ -0,0 +1,52 @@
+#include "encode.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#include <stdio.h>
+#include <ruby.h>
+#include<string.h>
+
+
+VALUE ENCODER = Qnil;  /* Ruby Module */
+
+const char *blurHashForFile(int xComponents, int yComponents,const char *filename);
+
+VALUE method_encode(VALUE self, VALUE x, VALUE y) {
+    int xComponents = NUM2INT(x);
+    int yComponents = NUM2INT(y);
+
+    const char * input_file = "tmp/in.png";
+
+    if(xComponents < 1 || xComponents > 8 || yComponents < 1 || yComponents > 8) {
+		fprintf(stderr, "Component counts must be between 1 and 8.\n");
+		return 1;
+	}
+
+	const char *hash = blurHashForFile(xComponents, yComponents, input_file);
+	if(!hash) {
+		fprintf(stderr, "Failed to load image file \"%s\".\n", input_file);
+		return 1;
+	}
+
+	return rb_str_new(hash, strlen(hash));
+}
+
+const char *blurHashForFile(int xComponents, int yComponents,const char *filename) {
+	int width, height, channels;
+	unsigned char *data = stbi_load(filename, &width, &height, &channels, 3);
+	if(!data) return NULL;
+
+	const char *hash = blurHashForPixels(xComponents, yComponents, width, height, data, width * 3);
+
+	stbi_image_free(data);
+
+	return hash;
+}
+
+void
+Init_blurhash_encoder(void) {
+    ENCODER = rb_define_module("ENCODER");
+    rb_define_method(ENCODER, "encode", method_encode, 2);
+}
+

data/ext/blurhash_encoder/common.h

@@ -0,0 +1,26 @@
+#ifndef __BLURHASH_COMMON_H__
+#define __BLURHASH_COMMON_H__
+
+#include<math.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+static inline int linearTosRGB(float value) {
+	float v = fmaxf(0, fminf(1, value));
+	if(v <= 0.0031308) return v * 12.92 * 255 + 0.5;
+	else return (1.055 * powf(v, 1 / 2.4) - 0.055) * 255 + 0.5;
+}
+
+static inline float sRGBToLinear(int value) {
+	float v = (float)value / 255;
+	if(v <= 0.04045) return v / 12.92;
+	else return powf((v + 0.055) / 1.055, 2.4);
+}
+
+static inline float signPow(float value, float exp) {
+	return copysignf(powf(fabsf(value), exp), value);
+}
+
+#endif

data/ext/blurhash_encoder/encode.c

@@ -0,0 +1,116 @@
+#include "encode.h"
+#include "common.h"
+
+#include <string.h>
+
+static float *multiplyBasisFunction(int xComponent, int yComponent, int width, int height, uint8_t *rgb, size_t bytesPerRow);
+static char *encode_int(int value, int length, char *destination);
+
+static int encodeDC(float r, float g, float b);
+static int encodeAC(float r, float g, float b, float maximumValue);
+
+const char *blurHashForPixels(int xComponents, int yComponents, int width, int height, uint8_t *rgb, size_t bytesPerRow) {
+	static char buffer[2 + 4 + (9 * 9 - 1) * 2 + 1];
+
+	if(xComponents < 1 || xComponents > 9) return NULL;
+	if(yComponents < 1 || yComponents > 9) return NULL;
+
+	float factors[yComponents][xComponents][3];
+	memset(factors, 0, sizeof(factors));
+
+	for(int y = 0; y < yComponents; y++) {
+		for(int x = 0; x < xComponents; x++) {
+			float *factor = multiplyBasisFunction(x, y, width, height, rgb, bytesPerRow);
+			factors[y][x][0] = factor[0];
+			factors[y][x][1] = factor[1];
+			factors[y][x][2] = factor[2];
+		}
+	}
+
+	float *dc = factors[0][0];
+	float *ac = dc + 3;
+	int acCount = xComponents * yComponents - 1;
+	char *ptr = buffer;
+
+	int sizeFlag = (xComponents - 1) + (yComponents - 1) * 9;
+	ptr = encode_int(sizeFlag, 1, ptr);
+
+	float maximumValue;
+	if(acCount > 0) {
+		float actualMaximumValue = 0;
+		for(int i = 0; i < acCount * 3; i++) {
+			actualMaximumValue = fmaxf(fabsf(ac[i]), actualMaximumValue);
+		}
+
+		int quantisedMaximumValue = fmaxf(0, fminf(82, floorf(actualMaximumValue * 166 - 0.5)));
+		maximumValue = ((float)quantisedMaximumValue + 1) / 166;
+		ptr = encode_int(quantisedMaximumValue, 1, ptr);
+	} else {
+		maximumValue = 1;
+		ptr = encode_int(0, 1, ptr);
+	}
+
+	ptr = encode_int(encodeDC(dc[0], dc[1], dc[2]), 4, ptr);
+
+	for(int i = 0; i < acCount; i++) {
+		ptr = encode_int(encodeAC(ac[i * 3 + 0], ac[i * 3 + 1], ac[i * 3 + 2], maximumValue), 2, ptr);
+	}
+
+	*ptr = 0;
+
+	return buffer;
+}
+
+static float *multiplyBasisFunction(int xComponent, int yComponent, int width, int height, uint8_t *rgb, size_t bytesPerRow) {
+	float r = 0, g = 0, b = 0;
+	float normalisation = (xComponent == 0 && yComponent == 0) ? 1 : 2;
+
+	for(int y = 0; y < height; y++) {
+		for(int x = 0; x < width; x++) {
+			float basis = cosf(M_PI * xComponent * x / width) * cosf(M_PI * yComponent * y / height);
+			r += basis * sRGBToLinear(rgb[3 * x + 0 + y * bytesPerRow]);
+			g += basis * sRGBToLinear(rgb[3 * x + 1 + y * bytesPerRow]);
+			b += basis * sRGBToLinear(rgb[3 * x + 2 + y * bytesPerRow]);
+		}
+	}
+
+	float scale = normalisation / (width * height);
+
+	static float result[3];
+	result[0] = r * scale;
+	result[1] = g * scale;
+	result[2] = b * scale;
+
+	return result;
+}
+
+
+
+static int encodeDC(float r, float g, float b) {
+	int roundedR = linearTosRGB(r);
+	int roundedG = linearTosRGB(g);
+	int roundedB = linearTosRGB(b);
+	return (roundedR << 16) + (roundedG << 8) + roundedB;
+}
+
+static int encodeAC(float r, float g, float b, float maximumValue) {
+	int quantR = fmaxf(0, fminf(18, floorf(signPow(r / maximumValue, 0.5) * 9 + 9.5)));
+	int quantG = fmaxf(0, fminf(18, floorf(signPow(g / maximumValue, 0.5) * 9 + 9.5)));
+	int quantB = fmaxf(0, fminf(18, floorf(signPow(b / maximumValue, 0.5) * 9 + 9.5)));
+
+	return quantR * 19 * 19 + quantG * 19 + quantB;
+}
+
+static char characters[83]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+
+static char *encode_int(int value, int length, char *destination) {
+	int divisor = 1;
+	for(int i = 0; i < length - 1; i++) divisor *= 83;
+
+	for(int i = 0; i < length; i++) {
+		int digit = (value / divisor) % 83;
+		divisor /= 83;
+		*destination++ = characters[digit];
+	}
+	return destination;
+}

data/ext/blurhash_encoder/encode.h

@@ -0,0 +1,9 @@
+#ifndef __BLURHASH_ENCODE_H__
+#define __BLURHASH_ENCODE_H__
+
+#include <stdint.h>
+#include <stdlib.h>
+
+const char *blurHashForPixels(int xComponents, int yComponents, int width, int height, uint8_t *rgb, size_t bytesPerRow);
+
+#endif