fast_thumbhash 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dd0e9e710dfa53775b6c718fd674fdc26fb0a17932058ca18e495b229d43e30
-  data.tar.gz: dc6e6c4203596d64bb3fb7e84fa63b72dda92cd5b7612a97371cb4ae418ae2af
+  metadata.gz: '029bcedcfcff9aeabbd3d052759f165228798ba5a4599747866b80c0e7cb2267'
+  data.tar.gz: c0284c796f2541a68ba0ce5d5f6d39362abc487d443ea92fe34f1cae84e49da2
 SHA512:
-  metadata.gz: 29c037a813de79ec9a791484823fc42291e2bbc6dd5c8c6a8ecc4d5e17b9de52dfcc64cd554372604bd8068cc5239e898b982f875e0f1efd62cac53967dabf05
-  data.tar.gz: 2d0f21baac23f3c28e024d6755a45cdae2c9f4b1dd78243ccd98e6fa6e9b01520f1ff28f9c113d4ab0a9c2ecc0988a0fa801c141310d760337c8f1ec37cc002b
+  metadata.gz: 8305727fad3e3d55f31265f05f3bad5931f6a6cb90787e896a8aacde19d3fa5aa75c122a3d6a7a977b0f0703c95323556527401816641148f69c25001b5b30e9
+  data.tar.gz: 77e126d32164ec0531b0ee450a950e59e7f872ca18d2fbb46e5544171f35f44066835817fb0f6cccce2625e806e5af9a280c238e7bd104de2125065e6b6e3cb8

data/.ruby-version

@@ -0,0 +1 @@
+2.7.8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fast_thumbhash (0.6.0)
+    fast_thumbhash (0.7.1)
       ffi
 
 GEM
@@ -52,6 +52,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
+  arm64-darwin-22
   x86_64-darwin-18
   x86_64-darwin-20
   x86_64-darwin-21

data/ext/fast_thumbhash/fast_thumbhash.c

@@ -67,14 +67,20 @@ encoded_channel encode_channel(double *channel, uint8_t nx, uint8_t ny, uint8_t
   return (encoded_channel){dc, ac, ac_length, scale};
 }
 
-void write_varying_factors(double *ac, int ac_size, uint8_t *thumbhash, uint8_t *ac_index) {
-  for (int i = 0; i < ac_size; i++) {
-    uint8_t index = (*ac_index) >> 1;
-    thumbhash[index] |= (uint8_t) roundf(15.0 * ac[i]) << (((*ac_index)++ & 1) << 2);
+uint8_t write_varying_factors(double *ac, int ac_size, uint8_t *thumbhash, uint8_t *ac_index)
+{
+  uint8_t index;
+
+  for (int i = 0; i < ac_size; i++)
+  {
+    index = (*ac_index) >> 1;
+    thumbhash[index] |= (uint8_t)roundf(15.0 * ac[i]) << (((*ac_index)++ & 1) << 2);
   }
+
+  return index;
 }
 
-void rgba_to_thumbhash(uint8_t w, uint8_t h, uint8_t *rgba, uint8_t *thumbhash)
+uint8_t rgba_to_thumbhash(uint8_t w, uint8_t h, uint8_t *rgba, uint8_t *thumbhash)
 {
   assert(w <= 100);
   assert(h <= 100);
@@ -143,28 +149,44 @@ void rgba_to_thumbhash(uint8_t w, uint8_t h, uint8_t *rgba, uint8_t *thumbhash)
   thumbhash[3] = (uint8_t)(header16 & 0xff);
   thumbhash[4] = (uint8_t)(header16 >> 8);
 
-  if (has_alpha) {
-    thumbhash[5] = (uint8_t) roundf(15.0 * ea.dc) | ((uint8_t) roundf(15.0 * ea.scale) << 4);
+  if (has_alpha)
+  {
+    thumbhash[5] = (uint8_t)roundf(15.0 * ea.dc) | ((uint8_t)roundf(15.0 * ea.scale) << 4);
   }
 
   uint8_t ac_start = has_alpha ? 6 : 5;
   uint8_t ac_index = 0;
 
-  write_varying_factors(el.ac, el.ac_size, thumbhash + ac_start, &ac_index);
-  write_varying_factors(ep.ac, ep.ac_size, thumbhash + ac_start, &ac_index);
-  write_varying_factors(eq.ac, eq.ac_size, thumbhash + ac_start, &ac_index);
+  uint8_t max_written_indexes[] = {0, 0, 0, 0};
+
+  max_written_indexes[0] = write_varying_factors(el.ac, el.ac_size, thumbhash + ac_start, &ac_index);
+  max_written_indexes[1] = write_varying_factors(ep.ac, ep.ac_size, thumbhash + ac_start, &ac_index);
+  max_written_indexes[2] = write_varying_factors(eq.ac, eq.ac_size, thumbhash + ac_start, &ac_index);
 
-  if (has_alpha) {
-    write_varying_factors(ea.ac, ea.ac_size, thumbhash + ac_start, &ac_index);
+  if (has_alpha)
+  {
+    max_written_indexes[3] = write_varying_factors(ea.ac, ea.ac_size, thumbhash + ac_start, &ac_index);
   }
 
   free(el.ac);
   free(ep.ac);
   free(eq.ac);
 
-  if (has_alpha) {
+  if (has_alpha)
+  {
     free(ea.ac);
   }
+
+  // store the largest number at max_written_indexes[0]
+  for (int i = 1; i < 4; ++i)
+  {
+    if (max_written_indexes[0] < max_written_indexes[i])
+    {
+      max_written_indexes[0] = max_written_indexes[i];
+    }
+  }
+
+  return max_written_indexes[0] + ac_start + 1;
 }
 
 double *decode_channel(uint8_t nx, uint8_t ny, double scale, uint8_t *hash, uint8_t ac_start, uint8_t *ac_index)
@@ -321,15 +343,14 @@ void hsv2rgb(float *hsv, uint8_t *rgb)
  * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.
  */
 void thumbhash_to_rgba(
-  uint8_t *hash,
-  uint8_t w,
-  uint8_t h,
-  enum FillMode fill_mode,
-  uint8_t *fill_color,
-  double *homogeneous_transform,
-  int saturation,
-  uint8_t *rgba
-)
+    uint8_t *hash,
+    uint8_t w,
+    uint8_t h,
+    enum FillMode fill_mode,
+    uint8_t *fill_color,
+    double *homogeneous_transform,
+    int saturation,
+    uint8_t *rgba)
 {
   // Read the constants
   u_int32_t header24 = hash[0] | (hash[1] << 8) | (hash[2] << 16);
@@ -343,7 +364,8 @@ void thumbhash_to_rgba(
   double q_scale = (double)((header16 >> 9) & 63) / 63;
   bool is_landscape = (header16 >> 15) != 0;
   uint8_t lx = fmax(3, is_landscape ? has_alpha ? 5 : 7 : header16 & 7);
-  uint8_t ly = fmax(3, is_landscape ? header16 & 7 : has_alpha ? 5 : 7);
+  uint8_t ly = fmax(3, is_landscape ? header16 & 7 : has_alpha ? 5
+                                                               : 7);
   double a_dc = (double)has_alpha ? (hash[5] & 15) / 15 : 1;
   double a_scale = (double)(hash[5] >> 4) / 15;
 
@@ -380,7 +402,8 @@ void thumbhash_to_rgba(
 
       double r, g, b, a;
 
-      if (fill_mode == CLAMP || fill_mode == BLUR) {
+      if (fill_mode == CLAMP || fill_mode == BLUR)
+      {
         if (x < 0)
         {
           x = 0;
@@ -401,7 +424,8 @@ void thumbhash_to_rgba(
 
       bool inside_image = x >= 0 && x <= 1.0 && y >= 0 && y <= 1.0;
 
-      if (inside_image) {
+      if (inside_image)
+      {
         double l = l_dc, p = p_dc, q = q_dc;
         a = a_dc;
 
@@ -455,7 +479,9 @@ void thumbhash_to_rgba(
         b = l - 2.0 / 3.0 * p;
         r = (3.0 * l - b + q) / 2.0;
         g = r - q;
-      } else {
+      }
+      else
+      {
         r = 255;
         g = 255;
         b = 255;
@@ -463,35 +489,37 @@ void thumbhash_to_rgba(
       }
 
       uint_fast8_t top[4] = {
-        fmax(0, 255 * fmin(1, r)),
-        fmax(0, 255 * fmin(1, g)),
-        fmax(0, 255 * fmin(1, b)),
-        fmax(0, 255 * fmin(1, a))
-      };
-
-      if (fill_color && fill_color[3] > 0) {
-        double top_a = (double) top[3] / 255.0;
-        double fill_color_a = (double) fill_color[3] / 255.0;
+          fmax(0, 255 * fmin(1, r)),
+          fmax(0, 255 * fmin(1, g)),
+          fmax(0, 255 * fmin(1, b)),
+          fmax(0, 255 * fmin(1, a))};
+
+      if (fill_color && fill_color[3] > 0)
+      {
+        double top_a = (double)top[3] / 255.0;
+        double fill_color_a = (double)fill_color[3] / 255.0;
         double inverse_top_a = 1.0 - top_a;
         double sum_a = top_a + fill_color_a * inverse_top_a;
 
         // Alpha compositing (top over fill_color)
-        rgba[i]   = roundf(((double) top[0] * top_a + (double) fill_color[0] * fill_color_a * inverse_top_a) / sum_a);
-        rgba[i+1] = roundf(((double) top[1] * top_a + (double) fill_color[1] * fill_color_a * inverse_top_a) / sum_a);
-        rgba[i+2] = roundf(((double) top[2] * top_a + (double) fill_color[2] * fill_color_a * inverse_top_a) / sum_a);
-        rgba[i+3] = roundf(sum_a * 255.0);
-      } else {
-        rgba[i]   = top[0];
-        rgba[i+1] = top[1];
-        rgba[i+2] = top[2];
-        rgba[i+3] = top[3];
+        rgba[i] = roundf(((double)top[0] * top_a + (double)fill_color[0] * fill_color_a * inverse_top_a) / sum_a);
+        rgba[i + 1] = roundf(((double)top[1] * top_a + (double)fill_color[1] * fill_color_a * inverse_top_a) / sum_a);
+        rgba[i + 2] = roundf(((double)top[2] * top_a + (double)fill_color[2] * fill_color_a * inverse_top_a) / sum_a);
+        rgba[i + 3] = roundf(sum_a * 255.0);
+      }
+      else
+      {
+        rgba[i] = top[0];
+        rgba[i + 1] = top[1];
+        rgba[i + 2] = top[2];
+        rgba[i + 3] = top[3];
       }
 
       if (saturation)
       {
         float hsv[3] = {0};
         rgb2hsv(rgba + i, hsv);
-        float mult = ((float) saturation + 100.0f) / 200.0f * 1.4f;
+        float mult = ((float)saturation + 100.0f) / 200.0f * 1.4f;
         hsv[1] = fminf(fmaxf(hsv[1] * mult, 0), 1.0f);
         hsv2rgb(hsv, rgba + i);
       }

data/ext/fast_thumbhash/fast_thumbhash.h

@@ -3,34 +3,32 @@
 
 #include <stdint.h>
 
-enum FillMode {
+enum FillMode
+{
   SOLID = 0,
   BLUR = 1,
   CLAMP = 2,
 };
 
-void rgba_to_thumbhash(
-  uint8_t w,
-  uint8_t h,
-  uint8_t *rgba,
-  uint8_t *thumbhash
-);
+uint8_t rgba_to_thumbhash(
+    uint8_t w,
+    uint8_t h,
+    uint8_t *rgba,
+    uint8_t *thumbhash);
 
 void thumb_size(
-  uint8_t *hash,
-  uint8_t max_size,
-  uint8_t *size
-);
+    uint8_t *hash,
+    uint8_t max_size,
+    uint8_t *size);
 
 void thumbhash_to_rgba(
-  uint8_t *hash,
-  uint8_t w,
-  uint8_t h,
-  enum FillMode fill_mode,
-  uint8_t *fill_color,
-  double *homogeneous_transform,
-  int saturation,
-  uint8_t *rgba
-);
+    uint8_t *hash,
+    uint8_t w,
+    uint8_t h,
+    enum FillMode fill_mode,
+    uint8_t *fill_color,
+    double *homogeneous_transform,
+    int saturation,
+    uint8_t *rgba);
 
 #endif

data/lib/fast_thumbhash/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastThumbhash
-  VERSION = "0.6.0"
+  VERSION = "0.7.1"
 end

data/lib/fast_thumbhash.rb

@@ -33,29 +33,66 @@ module FastThumbhash
     homogeneous_transform: nil,
     saturation: 0
   )
+    %i[solid blur clamp].include?(fill_mode) or
+      raise ArgumentError, "Invalid `fill_mode` option"
+
+    if fill_color
+      fill_color.length == 4 or
+        raise ArgumentError, "You need to pass [r, g, b, a] to the `fill_color` option"
+    end
+
+    raise ArgumentError, "Option `fill_color` is required for :solid fill_mode" if fill_mode == :solid && fill_color.nil?
+
+    if homogeneous_transform
+      (homogeneous_transform.size == 3 && homogeneous_transform.all? { |row| row.size == 3 }) or
+        raise ArgumentError, "`homogeneous_transform` option must be a 3x3 matrix"
+    end
+
+    if size
+      size.length == 2 or
+        raise ArgumentError, "You need to pass [width, height] to the `size` option"
+
+      size.all? { |dimension| dimension < 100 } or
+        raise ArgumentError, "Cannot generate images bigger then 100 pixels"
+    end
+
+    if max_size
+      max_size <= 100 or
+        raise ArgumentError, "Cannot generate images bigger then 100 pixels"
+    end
+
     !max_size.nil? ^ !size.nil? or
       raise ArgumentError, "Pass either the `max_size` option, or an explicit `size`"
 
-    %i[solid blur clamp].include?(fill_mode) or
-      raise ArgumentError, "Invalid `fill_mode` option"
+    binary_thumbhash_to_rgba!(
+      binary_thumbhash,
+      max_size: max_size,
+      size: size,
+      fill_mode: fill_mode,
+      fill_color: fill_color,
+      homogeneous_transform: homogeneous_transform,
+      saturation: saturation
+    )
+  end
 
+  def self.binary_thumbhash_to_rgba!(
+    binary_thumbhash,
+    max_size: nil,
+    size: nil,
+    fill_mode: :solid,
+    fill_color: [255, 255, 255, 0],
+    homogeneous_transform: nil,
+    saturation: 0
+  )
     fill_color_pointer =
       if fill_color
-        fill_color.length == 4 or
-          raise ArgumentError, "You need to pass [r, g, b, a] to the `fill_color` option"
-
         FFI::MemoryPointer.new(:uint8, 4).tap do |p|
           p.write_array_of_uint8(fill_color)
         end
       end
 
-    raise ArgumentError, "Option `fill_color` is required for :solid fill_mode" if fill_mode == :solid && fill_color.nil?
-
     transform_pointer =
       if homogeneous_transform
-        (homogeneous_transform.size == 3 && homogeneous_transform.all? { |row| row.size == 3 }) or
-          raise ArgumentError, "`homogeneous_transform` option must be a 3x3 matrix"
-
         FFI::MemoryPointer.new(:double, 6).tap do |p|
           p.write_array_of_double(
             [
@@ -75,17 +112,8 @@ module FastThumbhash
 
     width, height =
       if size
-        size.length == 2 or
-          raise ArgumentError, "You need to pass [width, height] to the `size` option"
-
-        size.all? { |dimension| dimension < 100 } or
-          raise ArgumentError, "Cannot generate images bigger then 100 pixels"
-
         size
       else
-        max_size <= 100 or
-          raise ArgumentError, "Cannot generate images bigger then 100 pixels"
-
         thumb_size_pointer = FFI::MemoryPointer.new(:uint8, 2)
         Library.thumb_size(thumbhash_pointer, max_size, thumb_size_pointer)
         thumb_size_pointer.read_array_of_uint8(2)
@@ -93,6 +121,7 @@ module FastThumbhash
 
     rgba_size = width * height * 4
     rgba_pointer = FFI::MemoryPointer.new(:uint8, rgba_size)
+
     Library.thumbhash_to_rgba(
       thumbhash_pointer,
       width,
@@ -100,7 +129,7 @@ module FastThumbhash
       fill_mode.to_sym,
       fill_color_pointer,
       transform_pointer,
-      saturation,
+      saturation.clamp(-100, 100),
       rgba_pointer
     )
 
@@ -126,10 +155,9 @@ module FastThumbhash
 
     thumbhash_pointer = FFI::MemoryPointer.new(:uint8, 25)
 
-    Library.rgba_to_thumbhash(width, height, rgba_pointer, thumbhash_pointer)
+    length = Library.rgba_to_thumbhash(width, height, rgba_pointer, thumbhash_pointer)
 
-    result = thumbhash_pointer.read_array_of_uint8(25)
-    result.pop while result.last.zero?
+    result = thumbhash_pointer.read_array_of_uint8(length)
 
     result.pack("C*")
   ensure
@@ -149,6 +177,6 @@ module FastThumbhash
 
     attach_function :thumb_size, %i[pointer uint8 pointer], :size_t
     attach_function :thumbhash_to_rgba, %i[pointer uint8 uint8 fill_mode pointer pointer int pointer], :void
-    attach_function :rgba_to_thumbhash, %i[uint8 uint8 pointer pointer], :void
+    attach_function :rgba_to_thumbhash, %i[uint8 uint8 pointer pointer], :uint8
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_thumbhash
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Stefano Verna
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-07 00:00:00.000000000 Z
+date: 2023-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -35,6 +35,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock