refactor: optimization + refactor

Author: naqvis

shard.yml

@@ -1,5 +1,5 @@
 name: crimage
-version: 1.0.4
+version: 1.0.5
 
 authors:
   - Ali Naqvi <syed.alinaqvi@gmail.com>

spec/jpeg/writer_spec.cr

@@ -76,6 +76,15 @@ describe CrImage::JPEG::Writer do
       end
     end
 
+    it "rejects empty image dimensions" do
+      img = CrImage::Gray.new(CrImage.rect(0, 0, 0, 0))
+      io = IO::Memory.new
+
+      expect_raises(CrImage::JPEG::FormatError, /dimensions must be positive/) do
+        CrImage::JPEG.write(io, img, 75)
+      end
+    end
+
     it "writes to file" do
       rect = CrImage.rect(0, 0, 8, 8)
       img = CrImage::Gray.new(rect)

spec/png/writer_spec.cr

@@ -63,13 +63,29 @@ module CrImage::PNG
       File.delete(path)
     end
 
-    it "handles empty image dimensions" do
+    it "rejects empty image dimensions" do
       img = CrImage::RGBA.new(CrImage.rect(0, 0, 0, 0))
+      io = IO::Memory.new
+      expect_raises(FormatError, /Invalid Image size/) do
+        PNG.write(io, img)
+      end
+    end
+
+    it "preserves palette transparency in read_config" do
+      palette = Color::Palette.new([
+        Color::NRGBA.new(0, 0, 0, 0).as(Color::Color),
+        Color::NRGBA.new(255, 255, 255, 255).as(Color::Color),
+      ])
+      img = CrImage::Paletted.new(CrImage.rect(0, 0, 2, 1), palette)
 
       io = IO::Memory.new
-      # Empty images are written successfully (0x0 PNG)
       PNG.write(io, img)
-      io.size.should be > 0
+      io.rewind
+
+      config = PNG.read_config(io)
+      config_palette = config.color_model.as(Color::Palette)
+      _, _, _, alpha = config_palette[0].rgba
+      alpha.should eq(0_u32)
     end
 
     it "writes NRGBA image" do

src/crimage/color/ycbcr.cr

@@ -1,6 +1,27 @@
 require "./color"
 
 module CrImage::Color
+  YCBCR_YY1_TABLE   = StaticArray(Int32, 256).new { |i| i.to_i32 * YCBCR_YY1_MULTIPLIER }
+  YCBCR_CB_B_TABLE  = StaticArray(Int32, 256).new { |i| RGB_FROM_CB_COEFF * (i.to_i32 - 128) }
+  YCBCR_CR_R_TABLE  = StaticArray(Int32, 256).new { |i| RGB_FROM_CR_COEFF * (i.to_i32 - 128) }
+  YCBCR_CB_G_TABLE  = StaticArray(Int32, 256).new { |i| RGB_FROM_CB_G_COEFF * (i.to_i32 - 128) }
+  YCBCR_CR_G_TABLE  = StaticArray(Int32, 256).new { |i| RGB_FROM_CR_G_COEFF * (i.to_i32 - 128) }
+  RGB_TO_Y_R_TABLE  = StaticArray(Int32, 256).new { |i| YCBCR_Y_R_COEFF * i.to_i32 }
+  RGB_TO_Y_G_TABLE  = StaticArray(Int32, 256).new { |i| YCBCR_Y_G_COEFF * i.to_i32 }
+  RGB_TO_Y_B_TABLE  = StaticArray(Int32, 256).new { |i| YCBCR_Y_B_COEFF * i.to_i32 }
+  RGB_TO_CB_R_TABLE = StaticArray(Int32, 256).new { |i| YCBCR_CB_R_COEFF * i.to_i32 }
+  RGB_TO_CB_G_TABLE = StaticArray(Int32, 256).new { |i| YCBCR_CB_G_COEFF * i.to_i32 }
+  RGB_TO_CB_B_TABLE = StaticArray(Int32, 256).new { |i| YCBCR_CB_B_COEFF * i.to_i32 }
+  RGB_TO_CR_R_TABLE = StaticArray(Int32, 256).new { |i| YCBCR_CR_R_COEFF * i.to_i32 }
+  RGB_TO_CR_G_TABLE = StaticArray(Int32, 256).new { |i| YCBCR_CR_G_COEFF * i.to_i32 }
+  RGB_TO_CR_B_TABLE = StaticArray(Int32, 256).new { |i| YCBCR_CR_B_COEFF * i.to_i32 }
+  YCBCR_RANGE_LIMIT = StaticArray(UInt8, 768).new do |i|
+    value = i.to_i32 - 256
+    value = 0 if value < 0
+    value = 255 if value > 255
+    value.to_u8
+  end
+
   # YCbCr represents a fully opaque 24-bit Y'CbCr color, having 8 bits each for
   # one luma and two chroma components.
   #
@@ -137,24 +158,20 @@ module CrImage::Color
     #	cr =  0.5000*r - 0.4187*g - 0.0813*b + 128
     # https:#www.w3.org/Graphics/JPEG/jfif3.pdf says y but means y'.
 
-    r1 = r.to_i32
-    g1 = g.to_i32
-    b1 = b.to_i32
-
     # yy is in range 0..0xff
     # Note that YCBCR_Y_R_COEFF + YCBCR_Y_G_COEFF + YCBCR_Y_B_COEFF equals 65536.
-    yy = (YCBCR_Y_R_COEFF*r1 + YCBCR_Y_G_COEFF*g1 + YCBCR_Y_B_COEFF*b1 + (1 << 15)) >> 16
+    yy = (RGB_TO_Y_R_TABLE[r] + RGB_TO_Y_G_TABLE[g] + RGB_TO_Y_B_TABLE[b] + (1 << 15)) >> 16
 
     # Note that YCBCR_CB_R_COEFF + YCBCR_CB_G_COEFF + YCBCR_CB_B_COEFF equals 0.
-    cb = YCBCR_CB_R_COEFF*r1 + YCBCR_CB_G_COEFF*g1 + YCBCR_CB_B_COEFF*b1 + YCBCR_CHROMA_OFFSET
+    cb = RGB_TO_CB_R_TABLE[r] + RGB_TO_CB_G_TABLE[g] + RGB_TO_CB_B_TABLE[b] + YCBCR_CHROMA_OFFSET
     if cb.to_u32! & 0xff000000 == 0
       cb >>= 16
     else
       cb = ~0 ^ (cb >> 31)
     end
 
     # Note that YCBCR_CR_R_COEFF + YCBCR_CR_G_COEFF + YCBCR_CR_B_COEFF equals 0.
-    cr = YCBCR_CR_R_COEFF*r1 + YCBCR_CR_G_COEFF*g1 + YCBCR_CR_B_COEFF*b1 + YCBCR_CHROMA_OFFSET
+    cr = RGB_TO_CR_R_TABLE[r] + RGB_TO_CR_G_TABLE[g] + RGB_TO_CR_B_TABLE[b] + YCBCR_CHROMA_OFFSET
     if cr.to_u32! & 0xff000000 == 0
       cr >>= 16
     else
@@ -255,31 +272,26 @@ module CrImage::Color
   # This is used internally for fast YCbCr to RGB conversion
   @[AlwaysInline]
   def self.ycbcr_to_rgb_16bit(y : UInt8, cb : UInt8, cr : UInt8) : {UInt32, UInt32, UInt32}
-    yy1 = y.to_i32 * YCBCR_YY1_MULTIPLIER
-    cb1 = cb.to_i32 - 128
-    cr1 = cr.to_i32 - 128
+    yy1 = YCBCR_YY1_TABLE[y]
 
-    r = yy1 + RGB_FROM_CR_COEFF*cr1
-    if r.to_u32! & 0xff000000 == 0
-      r >>= 8
-    else
-      r = (~0 ^ (r >> 31)) & 0xffff
-    end
+    r = clamp_ycbcr_16bit(yy1 + YCBCR_CR_R_TABLE[cr])
+    g = clamp_ycbcr_16bit(yy1 - YCBCR_CB_G_TABLE[cb] - YCBCR_CR_G_TABLE[cr])
+    b = clamp_ycbcr_16bit(yy1 + YCBCR_CB_B_TABLE[cb])
 
-    g = yy1 - RGB_FROM_CB_G_COEFF*cb1 - RGB_FROM_CR_G_COEFF*cr1
-    if g.to_u32! & 0xff000000 == 0
-      g >>= 8
-    else
-      g = (~0 ^ (g >> 31)) & 0xffff
-    end
+    {r, g, b}
+  end
 
-    b = yy1 + RGB_FROM_CB_COEFF*cb1
-    if b.to_u32! & 0xff000000 == 0
-      b >>= 8
+  @[AlwaysInline]
+  def self.clamp_ycbcr_16bit(value : Int32) : UInt32
+    if value.to_u32! & 0xff000000 == 0
+      (value >> 8).to_u32
     else
-      b = (~0 ^ (b >> 31)) & 0xffff
+      ((~0 ^ (value >> 31)) & 0xffff).to_u32
     end
+  end
 
-    {r.to_u32, g.to_u32, b.to_u32}
+  @[AlwaysInline]
+  def self.clamp_ycbcr_8bit(value : Int32) : UInt8
+    YCBCR_RANGE_LIMIT[(value >> 16) + 256]
   end
 end

src/crimage/jpeg/dct.cr

@@ -2,40 +2,73 @@
 # The DCT converts spatial image data into frequency domain for compression.
 module CrImage::JPEG
   # Forward Discrete Cosine Transform (DCT) implementation
-  # Uses direct formula for correctness
-  # Operates on 8x8 blocks
+  # Uses a separable 8x8 transform with precomputed coefficients.
   module DCT
+    SCALE = [
+      1.0 / ::Math.sqrt(8.0),
+      ::Math.sqrt(2.0 / 8.0),
+      ::Math.sqrt(2.0 / 8.0),
+      ::Math.sqrt(2.0 / 8.0),
+      ::Math.sqrt(2.0 / 8.0),
+      ::Math.sqrt(2.0 / 8.0),
+      ::Math.sqrt(2.0 / 8.0),
+      ::Math.sqrt(2.0 / 8.0),
+    ]
+
+    BASIS = [
+      [0.3535533905932738, 0.3535533905932738, 0.3535533905932738, 0.3535533905932738, 0.3535533905932738, 0.3535533905932738, 0.3535533905932738, 0.3535533905932738],
+      [0.4903926402016152, 0.4157348061512726, 0.27778511650980114, 0.09754516100806417, -0.0975451610080641, -0.277785116509801, -0.4157348061512727, -0.4903926402016152],
+      [0.46193976625564337, 0.19134171618254492, -0.19134171618254486, -0.46193976625564337, -0.4619397662556434, -0.19134171618254517, 0.191341716182545, 0.46193976625564326],
+      [0.4157348061512726, -0.0975451610080641, -0.4903926402016152, -0.2777851165098011, 0.2777851165098009, 0.4903926402016153, 0.0975451610080644, -0.41573480615127256],
+      [0.35355339059327384, -0.35355339059327373, -0.35355339059327384, 0.3535533905932737, 0.35355339059327384, -0.35355339059327334, -0.3535533905932733, 0.35355339059327323],
+      [0.27778511650980114, -0.4903926402016152, 0.09754516100806415, 0.41573480615127273, -0.41573480615127256, -0.09754516100806429, 0.49039264020161516, -0.27778511650980076],
+      [0.19134171618254495, -0.4619397662556434, 0.46193976625564326, -0.19134171618254528, -0.19134171618254495, 0.46193976625564315, -0.4619397662556437, 0.19134171618254314],
+      [0.09754516100806417, -0.2777851165098011, 0.41573480615127273, -0.4903926402016153, 0.4903926402016152, -0.415734806151272, 0.27778511650980076, -0.09754516100806251],
+    ]
+
     # Perform 2D DCT on an 8x8 block
     # Input: 64-element array of pixel values (0-255 range)
     # Output: 64-element array of DCT coefficients
     def self.transform(block : Array(Int32)) : Array(Int32)
+      result = Array(Int32).new(64, 0)
+      transform_into(block, result)
+      result
+    end
+
+    def self.transform_into(block : Indexable(Int32), result : Array(Int32)) : Nil
       raise ArgumentError.new("Block must have 64 elements") unless block.size == 64
+      raise ArgumentError.new("Result must have 64 elements") unless result.size == 64
 
-      # Create a working copy and shift values from [0, 255] to [-128, 127]
-      temp = block.map { |val| (val - 128).to_f64 }
+      shifted = StaticArray(Float64, 64).new(0.0)
+      temp = StaticArray(Float64, 64).new(0.0)
 
-      # Apply 2D DCT
-      result = Array(Float64).new(64, 0.0)
+      64.times do |i|
+        shifted[i] = (block[i] - 128).to_f64
+      end
 
-      8.times do |ver|
-        8.times do |hor|
+      8.times do |y|
+        row_base = y * 8
+        8.times do |u|
           sum = 0.0
-          8.times do |ypos|
-            8.times do |xpos|
-              sum += temp[ypos * 8 + xpos] *
-                     ::Math.cos((2 * xpos + 1) * hor * ::Math::PI / 16.0) *
-                     ::Math.cos((2 * ypos + 1) * ver * ::Math::PI / 16.0)
-            end
+          basis = BASIS[u]
+          8.times do |x|
+            sum += shifted[row_base + x] * basis[x]
           end
+          temp[row_base + u] = sum
+        end
+      end
 
-          # Apply normalization: (2/N) * C(u) * C(v) where N=8
-          cu = hor == 0 ? 1.0 / ::Math.sqrt(2.0) : 1.0
-          cv = ver == 0 ? 1.0 / ::Math.sqrt(2.0) : 1.0
-          result[ver * 8 + hor] = sum * 0.25 * cu * cv # 2/8 = 0.25
+      8.times do |v|
+        8.times do |u|
+          sum = 0.0
+          8.times do |y|
+            sum += BASIS[v][y] * temp[y * 8 + u]
+          end
+          result[v * 8 + u] = sum.round.to_i32
         end
       end
 
-      result.map(&.round.to_i32)
+      nil
     end
   end
 end