pura-webp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f68662dc2cbe5f2e2c4feeb36180b4a8fbe8227f059afc490ffeb9a636c90288
-  data.tar.gz: 8cb72c6e9fcab068f71a1f0a4a42b05a43343b4b0f14b4cf768dc2217c31bcbd
+  metadata.gz: 02daf4b19a84439a95985701909b9a269cfa02c74932440abe0cb2e369c66669
+  data.tar.gz: addad87ed565e4f4ffb906f03a50894737829dabf598180b76240c586b847266
 SHA512:
-  metadata.gz: 03aa144fae7b98ea9e1d921ea91d4ad699152ff83e30e2c106d229193077ede5a7fb7e37ce07e634d1beb7fd1b2fc9d07675bdb082be5f50b4fe63de42fcebf2
-  data.tar.gz: f0753fbe3a783224e2976f5c3d24ad814f950fb7a0d65c755bc741929cac703c05682c47baed9f030f6317af1513db016be5e4c69a9b4935aa21e8b6d4e28b28
+  metadata.gz: 3ec5fd7e14f33bea4582eeee83462b2ae6eaf880f45822a073df095ed0720dff8716740a94570a17a5c903b5cce5eac0cc378b602626ea2aea9e27a1fae003bf
+  data.tar.gz: 3e4d23bcd37b0bcfd1c5f2728affb2d8ab1425cbeeb658f1a92a0a26a428377d58a538007d26ee5193686b42ba1abf4c5f78cbaffa49aa5190671ffc34598ebb

data/LICENSE-GO

@@ -0,0 +1,35 @@
+The VP8 decoder in this gem (lib/pura/webp/decoder.rb,
+lib/pura/webp/bool_decoder.rb, and the static tables in
+lib/pura/webp/vp8_tables.rb) is a Ruby port of the Go package
+golang.org/x/image/vp8, which is distributed under the following
+BSD-3-Clause license:
+
+---
+
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google LLC nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -73,4 +73,10 @@ Decode performance on a 400×400 WebP image, Ruby 4.0.2 + YJIT:
 
 ## License
 
-MIT
+MIT — see [LICENSE](LICENSE).
+
+The VP8 decoder is a Ruby port of the Go package
+[golang.org/x/image/vp8](https://pkg.go.dev/golang.org/x/image/vp8),
+which is distributed under the BSD-3-Clause license. See
+[LICENSE-GO](LICENSE-GO) for that notice. The Go copyright is retained
+on the ported files as required.

data/lib/pura/webp/bool_decoder.rb

@@ -1,96 +1,111 @@
 # frozen_string_literal: true
 
+#
+# Ruby port of golang.org/x/image/vp8/partition.go. Copyright on the
+# Go original is retained; see LICENSE-GO for the upstream BSD-3-Clause
+# license. Modifications for Ruby are under the gem's MIT license.
+#
+# Copyright 2011 The Go Authors. All rights reserved.
+
 module Pura
   module Webp
+    # VP8 arithmetic bit decoder. Direct port of golang.org/x/image/vp8/partition.go.
+    # Follows libwebp's optimized formulation with precomputed shift/range lookup
+    # tables so normalization is O(1) per bit.
     class BoolDecoder
-      def initialize(data, offset = 0, size = nil)
-        @data = data
-        @pos = offset
-        @end_pos = size ? offset + size : data.bytesize
-
-        @range = 255
-        @value = 0
-        @bits_left = 0
-
-        load_initial
+      LUT_SHIFT = [
+        7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+      ].freeze
+
+      LUT_RANGE_M1 = [
+        127,
+        127, 191,
+        127, 159, 191, 223,
+        127, 143, 159, 175, 191, 207, 223, 239,
+        127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239, 247,
+        127, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167, 171, 175, 179, 183, 187,
+        191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251,
+        127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
+        159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189,
+        191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221,
+        223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253
+      ].freeze
+
+      UNIFORM_PROB = 128
+
+      attr_reader :unexpected_eof
+
+      def init(buf)
+        @buf = buf
+        @r = 0
+        @range_m1 = 254
+        @bits = 0
+        @n_bits = 0
+        @unexpected_eof = false
       end
 
-      def read_bool(prob)
-        split = 1 + (((@range - 1) * prob) >> 8)
-        big_split = split << @bits_left
+      def initialize(buf = nil)
+        init(buf) if buf
+      end
 
-        if @value >= big_split
-          @range -= split
-          @value -= big_split
-          bit = 1
+      # Reads a single arithmetic-coded bit. Returns true or false (not 0/1).
+      def read_bit(prob)
+        if @n_bits < 8
+          if @r >= @buf.bytesize
+            @unexpected_eof = true
+            return false
+          end
+          x = @buf.getbyte(@r)
+          @bits |= x << (8 - @n_bits)
+          @r += 1
+          @n_bits += 8
+        end
+        split = ((@range_m1 * prob) >> 8) + 1
+        bit = @bits >= (split << 8)
+        if bit
+          @range_m1 -= split
+          @bits -= split << 8
         else
-          @range = split
-          bit = 0
+          @range_m1 = split - 1
         end
-
-        normalize
-        bit
-      end
-
-      def read_literal(n)
-        val = 0
-        n.times do
-          val = (val << 1) | read_bool(128)
+        if @range_m1 < 127
+          shift = LUT_SHIFT[@range_m1]
+          @range_m1 = LUT_RANGE_M1[@range_m1]
+          @bits = (@bits << shift) & 0xFFFFFFFF
+          @n_bits -= shift
         end
-        val
-      end
-
-      def read_flag
-        read_bool(128) == 1
-      end
-
-      def read_signed(n)
-        val = read_literal(n)
-        read_flag ? -val : val
+        bit
       end
 
-      def read_tree(tree, probs)
-        idx = 0
-        loop do
-          idx += read_bool(probs[idx >> 1])
-          val = tree[idx]
-          return val if val <= 0
-
-          idx = val
+      # Reads an n-bit unsigned integer, MSB first.
+      def read_uint(prob, n)
+        u = 0
+        while n.positive?
+          n -= 1
+          u |= (1 << n) if read_bit(prob)
         end
+        u
       end
 
-      private
-
-      def load_initial
-        # Load enough bytes to fill value register
-        4.times do
-          if @pos < @end_pos
-            @value = (@value << 8) | @data.getbyte(@pos)
-            @pos += 1
-          else
-            @value <<= 8
-          end
-          @bits_left += 8
-        end
-        @bits_left -= 8 # We work with bits_left relative to range position
+      # Reads an n-bit signed integer: magnitude bits followed by sign bit.
+      def read_int(prob, n)
+        u = read_uint(prob, n)
+        read_bit(prob) ? -u : u
       end
 
-      def normalize
-        while @range < 128
-          @range <<= 1
-          @bits_left -= 1
-
-          next unless @bits_left.negative?
+      # Reads an "optional int": 1 prob-bit flag; if set, read n-bit signed int;
+      # otherwise return 0.
+      def read_optional_int(prob, n)
+        return 0 unless read_bit(prob)
 
-          @bits_left += 8
-          if @pos < @end_pos
-            @value = (@value << 8) | @data.getbyte(@pos)
-            @pos += 1
-          else
-            @value <<= 8
-          end
-        end
+        read_int(prob, n)
       end
     end
   end