blurhash_ruby 0.0.14

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef513fb805c4bdc62e5236843403bb3af8cb06c034c48ac2abc1a9d94a6863e8
+  data.tar.gz: 037752a9951af438c498f2caf27ab31f3717023124fa3c7e4300761cbb7f8c12
+SHA512:
+  metadata.gz: 751b20bc24a4a36e0f97121e1faabef567afdf04e3c9e69763b121a6c7c5c4e9746eeba1b38ef266467109985752868c9b9b26ec5930e2f0afff4f43a9a97e93
+  data.tar.gz: 4b69c4baef24c4e7d696a818b92a6d04d685a01c1c6f8865a84ce31d6102ab2709113ea72070220a87be349c832cc9c2ee49efef8a4e6fd3d82b6380b66eb217

data/.gitignore

@@ -0,0 +1,4 @@
+tmp
+lib/blurhash_decoder/binary/*.bundle
+lib/blurhash_encoder/binary/*.bundle
+*.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/README.md

@@ -0,0 +1 @@
+## Blurhash Ruby

data/Rakefile

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

data/blurhash_ruby.gemspec

@@ -0,0 +1,17 @@
+# lib = File.expand_path('../lib/', __FILE__)
+# $:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |s|
+    s.name        = 'blurhash_ruby'
+    s.version     = '0.0.14'
+    s.summary     = "A fast blurhash encoder/decoder gem!"
+    s.description = "A fast blurhash encoder/decoder gem."
+    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_ruby'
+    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,39 @@
+#include "decode.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_writer.h"
+#include <ruby.h>
+
+VALUE DECODER = Qnil;  /* Ruby Module */
+
+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;
+}
+
+void
+Init_blurhash_decoder(void) {
+    DECODER = rb_define_module("DECODER");
+    rb_define_method(DECODER, "decode", method_decode, 4);
+}
+

data/ext/blurhash_decoder/decode.c

@@ -0,0 +1,148 @@
+#include "decode.h"
+#include "../common.h"
+
+static char chars[83] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+
+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);
+	}
+}

data/ext/blurhash_decoder/decode.h

@@ -0,0 +1,54 @@
+#ifndef __BLURHASH_DECODE_H__
+
+#define __BLURHASH_DECODE_H
+
+#include <math.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+/*
+	decode : Returns the pixel array of the result image given the blurhash string,
+	Parameters : 
+		blurhash : A string representing the blurhash to be decoded.
+		width : Width of the resulting image
+		height : Height of the resulting image
+		punch : The factor to improve the contrast, default = 1
+		nChannels : Number of channels in the resulting image array, 3 = RGB, 4 = RGBA
+	Returns : A pointer to memory region where pixels are stored in (H, W, C) format
+*/
+uint8_t * decode(const char * blurhash, int width, int height, int punch, int nChannels);
+
+/*
+	decodeToArray : Decodes the blurhash and copies the pixels to pixelArray,
+					This method is suggested if you use an external memory allocator for pixelArray.
+					pixelArray should be of size : width * height * nChannels
+	Parameters :
+		blurhash : A string representing the blurhash to be decoded.
+		width : Width of the resulting image
+		height : Height of the resulting image
+		punch : The factor to improve the contrast, default = 1
+		nChannels : Number of channels in the resulting image array, 3 = RGB, 4 = RGBA
+		pixelArray : Pointer to memory region where pixels needs to be copied.
+	Returns : int, -1 if error 0 if successful
+*/
+int decodeToArray(const char * blurhash, int width, int height, int punch, int nChannels, uint8_t * pixelArray);
+
+/*
+	isValidBlurhash : Checks if the Blurhash is valid or not.
+	Parameters :
+		blurhash : A string representing the blurhash
+	Returns : bool (true if it is a valid blurhash, else false)
+*/
+bool isValidBlurhash(const char * blurhash); 
+
+/*
+	freePixelArray : Frees the pixel array
+	Parameters :
+		pixelArray : Pixel array pointer which will be freed.
+	Returns : void (None)
+*/
+void freePixelArray(uint8_t * pixelArray);
+
+#endif

data/ext/blurhash_decoder/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+abort "missing malloc()" unless have_func "malloc"
+abort "missing free()"   unless have_func "free"
+
+create_makefile("blurhash_decoder/blurhash_decoder")