From 7304e5e28c9cd5816aa4bb233322dbf8ffa8bc60 Mon Sep 17 00:00:00 2001
From: andri lim <jangko128@gmail.com>
Date: Mon, 13 Apr 2020 21:28:55 +0700
Subject: [PATCH] gc:arc refactor add LFS_MINSUM, LFS_BRUTEFORCE and add tests

---
 nimPNG/filters.nim     | 116 +++++++++++++++++++++++------------------
 nimPNG/nimz.nim        |   5 +-
 tests/test_filters.nim |  19 ++++++-
 3 files changed, 87 insertions(+), 53 deletions(-)

diff --git a/nimPNG/filters.nim b/nimPNG/filters.nim
index e60d6aa..81107ed 100644
--- a/nimPNG/filters.nim
+++ b/nimPNG/filters.nim
@@ -1,4 +1,4 @@
-import math
+import math, ../nimPNG/nimz
 
 type
   PNGFilter* = enum
@@ -101,55 +101,64 @@ proc filterZero*(output: var openArray[byte], input: openArray[byte], w, h, bpp:
       input.toOpenArray(prevIndex, input.len-1),
       byteWidth, lineBytes, FLT_NONE)
     prevIndex = inIndex
-    
-#[
+
+
 proc filterMinsum*(output: var openArray[byte], input: openArray[byte], w, h, bpp: int) =
   let lineBytes = (w * bpp + 7) div 8
   let byteWidth = (bpp + 7) div 8
 
   #adaptive filtering
-  var sum = [0, 0, 0, 0, 0]
-  var smallest = 0
-
-  #five filtering attempts, one for each filter type
-  var attempt: array[0..4, string]
-  var bestType = 0
-  var prevLine: DataBuf
+  var
+    sum = [0, 0, 0, 0, 0]
+    smallest = 0
+    # five filtering attempts, one for each filter type
+    attempt: array[0..4, seq[byte]]
+    bestType = 0
+    prevIndex = 0
 
   for i in 0..attempt.high:
-    attempt[i] = newString(lineBytes)
+    attempt[i] = newSeq[byte](lineBytes)
 
-  for y in 0..h-1:
-    #try the 5 filter types
+  for y in 0..<h:
+    # try the 5 filter types
+    let inIndex = y * lineBytes
     for fType in 0..4:
-      var outp = initBuffer(attempt[fType])
-      filterScanline(outp, input.subbuffer(y * lineBytes), prevLine, lineBytes, byteWidth, PNGFilter0(fType))
-      #calculate the sum of the result
+
+      if y == 0:
+        filterScanline(attempt[fType],
+          input.toOpenArray(inIndex, input.len-1),
+          byteWidth, lineBytes, PNGFilter(fType))
+      else:
+        filterScanline(attempt[fType],
+          input.toOpenArray(inIndex, input.len-1),
+          input.toOpenArray(prevIndex, input.len-1),
+          byteWidth, lineBytes, PNGFilter(fType))
+
+      # calculate the sum of the result
       sum[fType] = 0
       if fType == 0:
         for x in 0..lineBytes-1:
-          sum[fType] += ord(attempt[fType][x])
+          sum[fType] += int(attempt[fType][x])
       else:
         for x in 0..lineBytes-1:
-          #For differences, each byte should be treated as signed, values above 127 are negative
-          #(converted to signed char). Filtertype 0 isn't a difference though, so use unsigned there.
-          #This means filtertype 0 is almost never chosen, but that is justified.
-          let s = ord(attempt[fType][x])
+          # For differences, each byte should be treated as signed, values above 127 are negative
+          # (converted to signed char). Filtertype 0 isn't a difference though, so use unsigned there.
+          # This means filtertype 0 is almost never chosen, but that is justified.
+          let s = int(attempt[fType][x])
           if s < 128: sum[fType] += s
           else: sum[fType] += (255 - s)
 
-      #check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/
+      # check if this is smallest sum (or if type == 0 it's the first case so always store the values)
       if(fType == 0) or (sum[fType] < smallest):
         bestType = fType
         smallest = sum[fType]
 
-    prevLine = input.subbuffer(y * lineBytes)
-    #now fill the out values
-    #the first byte of a input will be the filter type
+    prevIndex = inIndex
+    # now fill the out values
+    # the first byte of a input will be the filter type
     output[y * (lineBytes + 1)] = byte(bestType)
     for x in 0..lineBytes-1:
       output[y * (lineBytes + 1) + 1 + x] = attempt[bestType][x]
-]#
 
 proc filterEntropy*(output: var openArray[byte], input: openArray[byte], w, h, bpp: int) =
   let lineBytes = (w * bpp + 7) div 8
@@ -227,38 +236,46 @@ proc filterPredefined*(output: var openArray[byte], input: openArray[byte],
       byteWidth, lineBytes, PNGFilter(fType))
     prevIndex = inIndex
 
-#[
-proc filterBruteForce(output: var DataBuf, input: DataBuf, w, h, bpp: int) =
+proc filterBruteForce*(output: var openArray[byte], input: openArray[byte], w, h, bpp: int) =
   let lineBytes = (w * bpp + 7) div 8
   let byteWidth = (bpp + 7) div 8
-  var prevLine: DataBuf
 
-  #brute force filter chooser.
-  #deflate the input after every filter attempt to see which one deflates best.
-  #This is very slow and gives only slightly smaller, sometimes even larger, result*/
+  # brute force filter chooser.
+  # deflate the input after every filter attempt to see which one deflates best.
+  # This is very slow and gives only slightly smaller, sometimes even larger, result*/
 
-  var size: array[0..4, int]
-  var attempt: array[0..4, string] #five filtering attempts, one for each filter type
-  var smallest = 0
-  var bestType = 0
+  var
+    size: array[0..4, int]
+    # five filtering attempts, one for each filter type
+    attempt: array[0..4, seq[byte]]
+    smallest = 0
+    bestType = 0
+    prevIndex = 0
 
-  #use fixed tree on the attempts so that the tree is not adapted to the filtertype on purpose,
-  #to simulate the true case where the tree is the same for the whole image. Sometimes it gives
-  #better result with dynamic tree anyway. Using the fixed tree sometimes gives worse, but in rare
-  #cases better compression. It does make this a bit less slow, so it's worth doing this.
+  # use fixed tree on the attempts so that the tree is not adapted to the filtertype on purpose,
+  # to simulate the true case where the tree is the same for the whole image. Sometimes it gives
+  # better result with dynamic tree anyway. Using the fixed tree sometimes gives worse, but in rare
+  # cases better compression. It does make this a bit less slow, so it's worth doing this.
 
   for i in 0..attempt.high:
-    attempt[i] = newString(lineBytes)
+    attempt[i] = newSeq[byte](lineBytes)
 
   for y in 0..h-1:
-    #try the 5 filter types
+    # try the 5 filter types
+    let inIndex = y * lineBytes
     for fType in 0..4:
-      #let testSize = attempt[fType].len
-      var outp = initBuffer(attempt[fType])
-      filterScanline(outp, input.subbuffer(y * lineBytes), prevLine, lineBytes, byteWidth, PNGFilter0(fType))
-      size[fType] = 0
+      if y == 0:
+        filterScanline(attempt[fType],
+          input.toOpenArray(inIndex, input.len-1),
+          byteWidth, lineBytes, PNGFilter(fType))
+      else:
+        filterScanline(attempt[fType],
+          input.toOpenArray(inIndex, input.len-1),
+          input.toOpenArray(prevIndex, input.len-1),
+          byteWidth, lineBytes, PNGFilter(fType))
 
-      var nz = nzDeflateInit(attempt[fType])
+      size[fType] = 0
+      var nz = nzCompressInit(attempt[fType])
       let data = zlib_compress(nz)
       size[fType] = data.len
 
@@ -267,11 +284,10 @@ proc filterBruteForce(output: var DataBuf, input: DataBuf, w, h, bpp: int) =
         bestType = fType
         smallest = size[fType]
 
-    prevLine = input.subbuffer(y * lineBytes)
-    output[y * (lineBytes + 1)] = byte(bestType) #the first byte of a input will be the filter type
+    prevIndex = inIndex
+    output[y * (lineBytes + 1)] = byte(bestType) # the first byte of a input will be the filter type
     for x in 0..lineBytes-1:
       output[y * (lineBytes + 1) + 1 + x] = attempt[bestType][x]
-]#
 
 proc unfilterScanline*(output: var openArray[byte], input: openArray[byte], byteWidth, len: int, filterType: PNGFilter) =
   # When the pixels are smaller than 1 byte, the filter works byte per byte (byteWidth = 1)
diff --git a/nimPNG/nimz.nim b/nimPNG/nimz.nim
index ed79d50..fc4cdb2 100644
--- a/nimPNG/nimz.nim
+++ b/nimPNG/nimz.nim
@@ -1,4 +1,4 @@
-import streams, sequtils, algorithm, strutils
+import sequtils
 
 const
   FIRST_LENGTH_CODE_INDEX = 257
@@ -1224,6 +1224,9 @@ proc nzDeflateInit*(input: string): nzStream =
 template nzCompressInit*(input: string): nzStream =
   nzDeflateInit(input)
 
+template nzCompressInit*(input: seq[byte]): nzStream =
+  nzDeflateInit(cast[string](input))
+
 proc nzInflateInit*(input: string): nzStream =
   var nz = nzInit()
   nz.data = newStringOfCap(1024 * 1024 * 5) # Allocate 5MB in advance
diff --git a/tests/test_filters.nim b/tests/test_filters.nim
index ea39dc4..d32371f 100644
--- a/tests/test_filters.nim
+++ b/tests/test_filters.nim
@@ -106,6 +106,12 @@ template roundTripZero(bpp: int) =
 template roundTripEntropy(bpp: int) =
   roundTripStrategy(bpp, filterEntropy)
 
+template roundTripMinsum(bpp: int) =
+  roundTripStrategy(bpp, filterMinsum)
+
+template roundTripBruteforce(bpp: int) =
+  roundTripStrategy(bpp, filterBruteforce)
+
 template roundTripPredefined(bpp: int) =
   block:
     let
@@ -152,8 +158,17 @@ proc testFilterStrategies() =
       roundTripEntropy(24)
       roundTripEntropy(32)
 
-    #of LFS_MINSUM: filterMinsum(output, input, w, h, bpp)
-    #of LFS_BRUTE_FORCE: filterBruteForce(output, input, w, h, bpp)
+    test "LFS_MINSUM":
+      roundTripMinsum(8)
+      roundTripMinsum(16)
+      roundTripMinsum(24)
+      roundTripMinsum(32)
+
+    test "LFS_BRUTEFORCE":
+      roundTripBruteforce(8)
+      roundTripBruteforce(16)
+      roundTripBruteforce(24)
+      roundTripBruteforce(32)
 
 proc main() =
   testFilterScanline()