blurhash_decoder 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b413ba2921f9347cc8f62b3b74c19bc4baa87d486b001178e0b19e423d303411
-  data.tar.gz: 7ca2a4c9f3e3208f9692aa4817ca5c79bad71429ace8ba787e86dd3a58ebb98a
+  metadata.gz: b0221d3511057d149926cc067e2a8e2eb51ff0c724476666e618df955160626e
+  data.tar.gz: a271106fec9b1e3872b0ab1a8ec7753e8b4e68a055887ba0dee57e9bd3964d1e
 SHA512:
-  metadata.gz: 8db69d6d4b520e2820501f8e59824ebd75663a99c2dc628730caaf3c6d93e21a908ee95e66826d04223d19485ef9948647b23d98d82fb8e27d2d7e7b300f041f
-  data.tar.gz: 367d99df65cac8c57f88a126e15f5f62902e1091d500ac2f4a519763fae54e02181764585db62223c30014aa398fe4cc39c5c6a8968c8aa20043a220999a02a9
+  metadata.gz: dbbb92c47bcb19a4445e58c1a22ec038642fce18d01209a9b528b70707c42905385164aaf48b9b0b9f2165f7d7a1118ccef7533b2e58e56e37ca862fba8d98a2
+  data.tar.gz: 125ef0207f696e1bf40055e8ffdbd14419b47ce83e0e7efb9bc7dfb79dbe55b685efa04c4d894a55d17a4cd00c010b7e437b2187167a4d6234df454c4c58ea12

data/.gitignore

@@ -0,0 +1,4 @@
+tmp
+lib/stuart_geo/*.bundle
+lib/stuart_geo/*.so
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "rake-compiler"

data/Gemfile.lock

@@ -0,0 +1,15 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.6)
+    rake-compiler (1.1.9)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake-compiler
+
+BUNDLED WITH
+   2.1.4

data/Rakefile

@@ -0,0 +1,9 @@
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "blurhash_decoder" do |ext|
+  ext.lib_dir = 'lib/blurhash_decoder'
+end
+
+Rake::ExtensionTask.new "blurhash_encoder" do |ext|
+  ext.lib_dir = 'lib/blurhash_encoder'
+end

data/blurhash_decoder.gemspec

@@ -0,0 +1,17 @@
+# lib = File.expand_path('../lib/', __FILE__)
+# $:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |s|
+    s.name        = 'blurhash_decoder'
+    s.version     = '0.0.11'
+    s.summary     = "A blurhash decoder gem!"
+    s.description = "A simple blurhash decoder gem using c."
+    s.authors     = ["Rabin Poudyal"]
+    s.email       = 'rabin@trip101.com'
+    s.files       = `git ls-files`.split("\n")
+    s.require_paths = %w(lib)
+    s.homepage    =
+        'https://rubygems.org/gems/blurhash_decoder'
+    s.license       = 'MIT'
+    s.extensions = %w[ext/blurhash_decoder/extconf.rb ext/blurhash_encoder/extconf.rb]
+end

data/ext/blurhash_decoder/blurhash_decoder.c

@@ -0,0 +1,205 @@
+#include <ruby.h>
+#include <stdio.h>
+#include<math.h>
+#include <stdbool.h>
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_writer.h"
+
+#define M_PI 3.14159265358979323846
+
+VALUE DECODER = Qnil;  /* Ruby Module */
+static char chars[83] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+
+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);
+}
+
+static inline uint8_t clampToUByte(int * src) {
+	if( *src >= 0 && *src <= 255 )
+		return *src;
+	return (*src < 0) ? 0 : 255;
+}
+
+static inline uint8_t *  createByteArray(int size) {
+	return (uint8_t *)malloc(size * sizeof(uint8_t));
+}
+
+int decodeToInt(const char * string, int start, int end) {
+	int value = 0, iter1 = 0, iter2 = 0;
+	for( iter1 = start; iter1 < end; iter1 ++) {
+		int index = -1;
+		for(iter2 = 0; iter2 < 83; iter2 ++) {
+			if (chars[iter2] == string[iter1]) {
+				index = iter2;
+				break;
+			}
+		}
+		if (index == -1) return -1;
+		value = value * 83 + index;
+	}
+	return value;
+}
+
+bool isValidBlurhash(const char * blurhash) {
+
+	const int hashLength = strlen(blurhash);
+
+	if ( !blurhash || strlen(blurhash) < 6) return false;
+
+	int sizeFlag = decodeToInt(blurhash, 0, 1);	//Get size from first character
+	int numY = (int)floorf(sizeFlag / 9) + 1;
+	int numX = (sizeFlag % 9) + 1;
+
+	if (hashLength != 4 + 2 * numX * numY) return false;
+	return true;
+}
+
+void decodeDC(int value, float * r, float * g, float * b) {
+	*r = sRGBToLinear(value >> 16); 	// R-component
+	*g = sRGBToLinear((value >> 8) & 255); // G-Component
+	*b = sRGBToLinear(value & 255);	// B-Component
+}
+
+void decodeAC(int value, float maximumValue, float * r, float * g, float * b) {
+	int quantR = (int)floorf(value / (19 * 19));
+	int quantG = (int)floorf(value / 19) % 19;
+	int quantB = (int)value % 19;
+
+	*r = signPow(((float)quantR - 9) / 9, 2.0) * maximumValue;
+	*g = signPow(((float)quantG - 9) / 9, 2.0) * maximumValue;
+	*b = signPow(((float)quantB - 9) / 9, 2.0) * maximumValue;
+}
+
+int decodeToArray(const char * blurhash, int width, int height, int punch, int nChannels, uint8_t * pixelArray) {
+	if (! isValidBlurhash(blurhash)) return -1;
+	if (punch < 1) punch = 1;
+
+	int sizeFlag = decodeToInt(blurhash, 0, 1);
+	int numY = (int)floorf(sizeFlag / 9) + 1;
+	int numX = (sizeFlag % 9) + 1;
+	int iter = 0;
+
+	float r = 0, g = 0, b = 0;
+	int quantizedMaxValue = decodeToInt(blurhash, 1, 2);
+	if (quantizedMaxValue == -1) return -1;
+
+	float maxValue = ((float)(quantizedMaxValue + 1)) / 166;
+
+	int colors_size = numX * numY;
+	float colors[colors_size][3];
+
+	for(iter = 0; iter < colors_size; iter ++) {
+		if (iter == 0) {
+			int value = decodeToInt(blurhash, 2, 6);
+			if (value == -1) return -1;
+			decodeDC(value, &r, &g, &b);
+			colors[iter][0] = r;
+			colors[iter][1] = g;
+			colors[iter][2] = b;
+
+		} else {
+			int value = decodeToInt(blurhash, 4 + iter * 2, 6 + iter * 2);
+			if (value == -1) return -1;
+			decodeAC(value, maxValue * punch, &r, &g, &b);
+			colors[iter][0] = r;
+			colors[iter][1] = g;
+			colors[iter][2] = b;
+		}
+	}
+
+	int bytesPerRow = width * nChannels;
+	int x = 0, y = 0, i = 0, j = 0;
+	int intR = 0, intG = 0, intB = 0;
+
+	for(y = 0; y < height; y ++) {
+		for(x = 0; x < width; x ++) {
+
+			float r = 0, g = 0, b = 0;
+
+			for(j = 0; j < numY; j ++) {
+				for(i = 0; i < numX; i ++) {
+					float basics = cos((M_PI * x * i) / width) * cos((M_PI * y * j) / height);
+					int idx = i + j * numX;
+					r += colors[idx][0] * basics;
+					g += colors[idx][1] * basics;
+					b += colors[idx][2] * basics;
+				}
+			}
+
+			intR = linearTosRGB(r);
+			intG = linearTosRGB(g);
+			intB = linearTosRGB(b);
+
+			pixelArray[nChannels * x + 0 + y * bytesPerRow] = clampToUByte(&intR);
+			pixelArray[nChannels * x + 1 + y * bytesPerRow] = clampToUByte(&intG);
+			pixelArray[nChannels * x + 2 + y * bytesPerRow] = clampToUByte(&intB);
+
+			if (nChannels == 4)
+				pixelArray[nChannels * x + 3 + y * bytesPerRow] = 255;   // If nChannels=4, treat each pixel as RGBA instead of RGB
+
+		}
+	}
+
+	return 0;
+}
+
+uint8_t * decode(const char * blurhash, int width, int height, int punch, int nChannels) {
+	int bytesPerRow = width * nChannels;
+	uint8_t * pixelArray = createByteArray(bytesPerRow * height);
+
+	if (decodeToArray(blurhash, width, height, punch, nChannels, pixelArray) == -1)
+		return NULL;
+	return pixelArray;
+}
+
+void freePixelArray(uint8_t * pixelArray) {
+	if (pixelArray) {
+		free(pixelArray);
+	}
+}
+
+VALUE method_decode(VALUE self, VALUE blurhash, VALUE heigh, VALUE widt, VALUE punc) {
+    const char * hash = StringValuePtr(blurhash);
+    int height = NUM2INT(heigh);
+    int width = NUM2INT(widt);
+    int punch = NUM2INT(punc);
+
+    const char * output_file = "tmp/out.png";
+
+    const int nChannels = 4;
+
+    uint8_t * bytes = decode(hash, width, height, punch, nChannels);
+    if (!bytes) {
+		// fprintf(stderr, "%s is not a valid blurhash, decoding failed.\n", hash);
+		return 1;
+	}
+
+	if (stbi_write_png(output_file, width, height, nChannels, bytes, nChannels * width) == 0) {
+		// fprintf(stderr, "Failed to write PNG file %s\n", output_file);
+		return 1;
+	}
+    freePixelArray(bytes);
+    // fprintf(stdout, "Decoded blurhash successfully, wrote PNG file %s\n", output_file);
+    return 0;
+    // return rb_float_new(5);  /* Convert C double to Ruby float */
+}
+
+void
+Init_blurhash_decoder(void) {
+    DECODER = rb_define_module("DECODER");
+    rb_define_method(DECODER, "decode", method_decode, 4);
+}
+