mirror of https://github.com/status-im/nimPNG.git
gc:arc refactor 'filterScanline' and add tests
This commit is contained in:
andri lim
parent
27e76f2d65
commit
43d5548237
|
|
@ -13,10 +13,13 @@ task tests, "Run tests":
|
||||||
exec "nim c -r tests/test_codec.nim"
|
exec "nim c -r tests/test_codec.nim"
|
||||||
exec "nim c -r tests/test_suite.nim"
|
exec "nim c -r tests/test_suite.nim"
|
||||||
exec "nim c -r tests/test_nimz.nim"
|
exec "nim c -r tests/test_nimz.nim"
|
||||||
|
exec "nim c -r tests/test_filters.nim"
|
||||||
|
|
||||||
exec "nim c -r -d:release tests/test_apng.nim"
|
exec "nim c -r -d:release tests/test_apng.nim"
|
||||||
exec "nim c -r -d:release tests/test_codec.nim"
|
exec "nim c -r -d:release tests/test_codec.nim"
|
||||||
exec "nim c -r -d:release tests/test_suite.nim"
|
exec "nim c -r -d:release tests/test_suite.nim"
|
||||||
exec "nim c -r -d:release tests/test_nimz.nim"
|
exec "nim c -r -d:release tests/test_nimz.nim"
|
||||||
|
exec "nim c -r -d:release tests/test_filters.nim"
|
||||||
|
|
||||||
exec "nim c -r --gc:arc -d:release tests/test_nimz.nim"
|
exec "nim c -r --gc:arc -d:release tests/test_nimz.nim"
|
||||||
|
exec "nim c -r --gc:arc -d:release tests/test_filters.nim"
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,310 @@
|
||||||
|
type
|
||||||
|
PNGFilter* = enum
|
||||||
|
FLT_NONE,
|
||||||
|
FLT_SUB,
|
||||||
|
FLT_UP,
|
||||||
|
FLT_AVERAGE,
|
||||||
|
FLT_PAETH
|
||||||
|
|
||||||
|
# Paeth predicter, used by PNG filter type 4
|
||||||
|
proc paethPredictor(a, b, c: int): uint =
|
||||||
|
let pa = abs(b - c)
|
||||||
|
let pb = abs(a - c)
|
||||||
|
let pc = abs(a + b - c - c)
|
||||||
|
|
||||||
|
if(pc < pa) and (pc < pb): return c.uint
|
||||||
|
elif pb < pa: return b.uint
|
||||||
|
result = a.uint
|
||||||
|
|
||||||
|
proc filterScanline*(output: var openArray[byte], input: openArray[byte], byteWidth, len: int, filterType: PNGFilter) =
|
||||||
|
template currPix: untyped = input[i].uint
|
||||||
|
template prevPix: untyped = input[i - byteWidth].uint
|
||||||
|
|
||||||
|
case filterType
|
||||||
|
of FLT_NONE:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = input[i]
|
||||||
|
of FLT_SUB:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix - prevPix) and 0xFF)
|
||||||
|
of FLT_UP:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = input[i]
|
||||||
|
of FLT_AVERAGE:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix - (prevPix div 2)) and 0xFF)
|
||||||
|
of FLT_PAETH:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
#paethPredictor(prevPix, 0, 0) is always prevPix
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix - prevPix) and 0xFF)
|
||||||
|
|
||||||
|
proc filterScanline*(output: var openArray[byte], input, prevLine: openArray[byte], byteWidth, len: int, filterType: PNGFilter) =
|
||||||
|
template currPix: untyped = input[i].uint
|
||||||
|
template prevPix: untyped = input[i - byteWidth].uint
|
||||||
|
template upPix: untyped = prevLine[i].uint
|
||||||
|
template prevPixI: untyped = input[i - byteWidth].int
|
||||||
|
template upPixI: untyped = prevLine[i].int
|
||||||
|
template prevUpPix: untyped = prevLine[i - byteWidth].int
|
||||||
|
|
||||||
|
case filterType
|
||||||
|
of FLT_NONE:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = input[i]
|
||||||
|
of FLT_SUB:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix - prevPix) and 0xFF)
|
||||||
|
of FLT_UP:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = byte((currPix - upPix) and 0xFF)
|
||||||
|
of FLT_AVERAGE:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = byte((currPix - (upPix div 2)) and 0xFF)
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix - ((prevPix + upPix) div 2)) and 0xFF)
|
||||||
|
of FLT_PAETH:
|
||||||
|
#paethPredictor(0, upPix, 0) is always upPix
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = byte((currPix - upPix) and 0xFF)
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix - paethPredictor(prevPixI, upPixI, prevUpPix)) and 0xFF)
|
||||||
|
#[
|
||||||
|
proc filterZero(output: var DataBuf, input: DataBuf, w, h, bpp: int) =
|
||||||
|
#the width of a input in bytes, not including the filter type
|
||||||
|
let lineBytes = (w * bpp + 7) div 8
|
||||||
|
#byteWidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise
|
||||||
|
let byteWidth = (bpp + 7) div 8
|
||||||
|
var prevLine: DataBuf
|
||||||
|
|
||||||
|
for y in 0..h-1:
|
||||||
|
let outindex = (1 + lineBytes) * y #the extra filterbyte added to each row
|
||||||
|
let inindex = lineBytes * y
|
||||||
|
output[outindex] = byte(int(FLT_NONE)) #filter type byte
|
||||||
|
var outp = output.subbuffer(outindex + 1)
|
||||||
|
let input = input.subbuffer(inindex)
|
||||||
|
filterScanline(outp, input, prevLine, lineBytes, byteWidth, FLT_NONE)
|
||||||
|
prevLine = input.subbuffer(inindex)
|
||||||
|
|
||||||
|
proc filterMinsum(output: var DataBuf, input: DataBuf, 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
|
||||||
|
|
||||||
|
for i in 0..attempt.high:
|
||||||
|
attempt[i] = newString(lineBytes)
|
||||||
|
|
||||||
|
for y in 0..h-1:
|
||||||
|
#try the 5 filter types
|
||||||
|
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
|
||||||
|
sum[fType] = 0
|
||||||
|
if fType == 0:
|
||||||
|
for x in 0..lineBytes-1:
|
||||||
|
sum[fType] += ord(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])
|
||||||
|
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)*/
|
||||||
|
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
|
||||||
|
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 DataBuf, input: DataBuf, w, h, bpp: int) =
|
||||||
|
let lineBytes = (w * bpp + 7) div 8
|
||||||
|
let byteWidth = (bpp + 7) div 8
|
||||||
|
var prevLine: DataBuf
|
||||||
|
|
||||||
|
var sum: array[0..4, float]
|
||||||
|
var smallest = 0.0
|
||||||
|
var bestType = 0
|
||||||
|
var attempt: array[0..4, string]
|
||||||
|
var count: array[0..255, int]
|
||||||
|
|
||||||
|
for i in 0..attempt.high:
|
||||||
|
attempt[i] = newString(lineBytes)
|
||||||
|
|
||||||
|
for y in 0..h-1:
|
||||||
|
#try the 5 filter types
|
||||||
|
for fType in 0..4:
|
||||||
|
var outp = initBuffer(attempt[fType])
|
||||||
|
filterScanline(outp, input.subbuffer(y * lineBytes), prevLine, lineBytes, byteWidth, PNGFilter0(fType))
|
||||||
|
for x in 0..255: count[x] = 0
|
||||||
|
for x in 0..lineBytes-1:
|
||||||
|
inc count[ord(attempt[fType][x])]
|
||||||
|
inc count[fType] #the filter type itself is part of the input
|
||||||
|
sum[fType] = 0
|
||||||
|
for x in 0..255:
|
||||||
|
let p = float(count[x]) / float(lineBytes + 1)
|
||||||
|
if count[x] != 0: sum[fType] += log2(1 / p) * p
|
||||||
|
|
||||||
|
#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
|
||||||
|
output[y * (lineBytes + 1)] = byte(bestType)
|
||||||
|
for x in 0..lineBytes-1:
|
||||||
|
output[y * (lineBytes + 1) + 1 + x] = attempt[bestType][x]
|
||||||
|
|
||||||
|
proc filterPredefined(output: var DataBuf, input: DataBuf, w, h, bpp: int, state: PNGEncoder) =
|
||||||
|
let lineBytes = (w * bpp + 7) div 8
|
||||||
|
let byteWidth = (bpp + 7) div 8
|
||||||
|
var prevLine: DataBuf
|
||||||
|
|
||||||
|
for y in 0..h-1:
|
||||||
|
let outindex = (1 + lineBytes) * y #the extra filterbyte added to each row
|
||||||
|
let inindex = lineBytes * y
|
||||||
|
let fType = ord(state.predefinedFilters[y])
|
||||||
|
output[outindex] = byte(fType) #filter type byte
|
||||||
|
var outp = output.subbuffer(outindex + 1)
|
||||||
|
filterScanline(outp, input.subbuffer(inindex), prevLine, lineBytes, byteWidth, PNGFilter0(fType))
|
||||||
|
prevLine = input.subbuffer(inindex)
|
||||||
|
|
||||||
|
proc filterBruteForce(output: var DataBuf, input: DataBuf, 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*/
|
||||||
|
|
||||||
|
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
|
||||||
|
|
||||||
|
#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)
|
||||||
|
|
||||||
|
for y in 0..h-1:
|
||||||
|
#try the 5 filter types
|
||||||
|
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
|
||||||
|
|
||||||
|
var nz = nzDeflateInit(attempt[fType])
|
||||||
|
let data = zlib_compress(nz)
|
||||||
|
size[fType] = data.len
|
||||||
|
|
||||||
|
#check if this is smallest size (or if type == 0 it's the first case so always store the values)
|
||||||
|
if(fType == 0) or (size[fType] < smallest):
|
||||||
|
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
|
||||||
|
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)
|
||||||
|
# the incoming inputs do NOT include the filtertype byte, that one is given in the parameter filterType instead
|
||||||
|
# output and input MAY be the same memory address! output must be disjoint.
|
||||||
|
|
||||||
|
template currPix: untyped = input[i].uint
|
||||||
|
template prevPix: untyped = output[i - byteWidth].uint
|
||||||
|
|
||||||
|
case filterType
|
||||||
|
of FLT_NONE:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = input[i]
|
||||||
|
of FLT_SUB:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix + prevPix) and 0xFF)
|
||||||
|
of FLT_UP:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = input[i]
|
||||||
|
of FLT_AVERAGE:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix + (prevPix div 2)) and 0xFF)
|
||||||
|
of FLT_PAETH:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
# paethPredictor(prevPix, 0, 0) is always prevPix
|
||||||
|
output[i] = byte((currPix + prevPix) and 0xFF)
|
||||||
|
|
||||||
|
proc unfilterScanline*(output: var openArray[byte], input, prevLine: openArray[byte], byteWidth, len: int, filterType: PNGFilter) =
|
||||||
|
# For PNG filter method 0
|
||||||
|
# unfilter a PNG image input by input. when the pixels are smaller than 1 byte,
|
||||||
|
# the filter works byte per byte (byteWidth = 1)
|
||||||
|
# prevLine is the previous unfiltered input, output the result, input the current one
|
||||||
|
# the incoming inputs do NOT include the filtertype byte, that one is given in the parameter filterType instead
|
||||||
|
# output and input MAY be the same memory address! prevLine must be disjoint.
|
||||||
|
|
||||||
|
template currPix: untyped = input[i].uint
|
||||||
|
template prevPix: untyped = output[i - byteWidth].uint
|
||||||
|
template upPix: untyped = prevLine[i].uint
|
||||||
|
template prevPixI: untyped = output[i - byteWidth].int
|
||||||
|
template upPixI: untyped = prevLine[i].int
|
||||||
|
template prevUpPix: untyped = prevLine[i - byteWidth].int
|
||||||
|
|
||||||
|
case filterType
|
||||||
|
of FLT_NONE:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = input[i]
|
||||||
|
of FLT_SUB:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = input[i]
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix + prevPix) and 0xFF)
|
||||||
|
of FLT_UP:
|
||||||
|
for i in 0..<len:
|
||||||
|
output[i] = byte((currPix + upPix) and 0xFF)
|
||||||
|
of FLT_AVERAGE:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
output[i] = byte((currPix + upPix div 2) and 0xFF)
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix + ((prevPix + upPix) div 2)) and 0xFF)
|
||||||
|
of FLT_PAETH:
|
||||||
|
for i in 0..<byteWidth:
|
||||||
|
# paethPredictor(0, upPix, 0) is always upPix
|
||||||
|
output[i] = byte((currPix + upPix) and 0xFF)
|
||||||
|
for i in byteWidth..<len:
|
||||||
|
output[i] = byte((currPix + paethPredictor(prevPixI, upPixI, prevUpPix)) and 0xFF)
|
||||||
|
|
@ -0,0 +1,58 @@
|
||||||
|
import random, sets
|
||||||
|
|
||||||
|
type
|
||||||
|
RandGen*[T] = object
|
||||||
|
minVal, maxVal: T
|
||||||
|
|
||||||
|
Bytes* = seq[byte]
|
||||||
|
|
||||||
|
proc rng*[T](minVal, maxVal: T): RandGen[T] =
|
||||||
|
doAssert(minVal <= maxVal)
|
||||||
|
result.minVal = minVal
|
||||||
|
result.maxVal = maxVal
|
||||||
|
|
||||||
|
proc rng*[T](minMax: T): RandGen[T] =
|
||||||
|
rng(minMax, minMax)
|
||||||
|
|
||||||
|
proc getVal*[T](x: RandGen[T]): T =
|
||||||
|
if x.minVal == x.maxVal: return x.minVal
|
||||||
|
rand(x.minVal..x.maxVal)
|
||||||
|
|
||||||
|
proc randString*(len: int): string =
|
||||||
|
result = newString(len)
|
||||||
|
for i in 0..<len:
|
||||||
|
result[i] = rand(255).char
|
||||||
|
|
||||||
|
proc randBytes*(len: int): Bytes =
|
||||||
|
result = newSeq[byte](len)
|
||||||
|
for i in 0..<len:
|
||||||
|
result[i] = rand(255).byte
|
||||||
|
|
||||||
|
proc randPrimitives*[T](val: int): T =
|
||||||
|
when T is string:
|
||||||
|
randString(val)
|
||||||
|
elif T is int:
|
||||||
|
result = val
|
||||||
|
elif T is byte:
|
||||||
|
result = val.byte
|
||||||
|
elif T is Bytes:
|
||||||
|
result = randBytes(val)
|
||||||
|
|
||||||
|
proc randList*(T: typedesc, fillGen: RandGen, listLen: int, unique: static[bool] = true): seq[T] =
|
||||||
|
result = newSeqOfCap[T](listLen)
|
||||||
|
when unique:
|
||||||
|
var set = initSet[T]()
|
||||||
|
for len in 0..<listLen:
|
||||||
|
while true:
|
||||||
|
let x = randPrimitives[T](fillGen.getVal())
|
||||||
|
if x notin set:
|
||||||
|
result.add x
|
||||||
|
set.incl x
|
||||||
|
break
|
||||||
|
else:
|
||||||
|
for len in 0..<listLen:
|
||||||
|
let x = randPrimitives[T](fillGen.getVal())
|
||||||
|
result.add x
|
||||||
|
|
||||||
|
proc randList*(T: typedesc, fillGen, listGen: RandGen, unique: static[bool] = true): seq[T] =
|
||||||
|
randList(T, fillGen, listGen.getVal(), unique)
|
||||||
|
|
@ -0,0 +1,97 @@
|
||||||
|
import ../nimPNG/filters, ./randutils, unittest
|
||||||
|
|
||||||
|
template roundTripFilter(byteWidth: int, filter: PNGFilter) =
|
||||||
|
filterScanline(outPix, inPix, byteWidth, lineBytes, filter)
|
||||||
|
unfilterScanline(oriPix, outPix, byteWidth, lineBytes, filter)
|
||||||
|
check oriPix == inPix
|
||||||
|
|
||||||
|
template roundTripFilterP(byteWidth: int, filter: PNGFilter) =
|
||||||
|
# with prevLine
|
||||||
|
filterScanline(outPix, inPix, prevLine, byteWidth, lineBytes, filter)
|
||||||
|
unfilterScanline(oriPix, outPix, prevLine, byteWidth, lineBytes, filter)
|
||||||
|
check oriPix == inPix
|
||||||
|
|
||||||
|
proc testFilterScanline() =
|
||||||
|
suite "filterScanline":
|
||||||
|
const
|
||||||
|
lineBytes = 128
|
||||||
|
|
||||||
|
let
|
||||||
|
inPix = randList(byte, rng(0, 255), lineBytes, unique = false)
|
||||||
|
prevLine = randList(byte, rng(0, 255), lineBytes, unique = false)
|
||||||
|
|
||||||
|
var
|
||||||
|
outPix = newSeq[byte](lineBytes)
|
||||||
|
oriPix = newSeq[byte](lineBytes)
|
||||||
|
|
||||||
|
test "FLT_NONE":
|
||||||
|
roundTripFilter(1, FLT_NONE)
|
||||||
|
roundTripFilter(2, FLT_NONE)
|
||||||
|
roundTripFilter(3, FLT_NONE)
|
||||||
|
roundTripFilter(4, FLT_NONE)
|
||||||
|
|
||||||
|
test "FLT_SUB":
|
||||||
|
roundTripFilter(1, FLT_SUB)
|
||||||
|
roundTripFilter(2, FLT_SUB)
|
||||||
|
roundTripFilter(3, FLT_SUB)
|
||||||
|
roundTripFilter(4, FLT_SUB)
|
||||||
|
|
||||||
|
test "FLT_UP":
|
||||||
|
roundTripFilter(1, FLT_UP)
|
||||||
|
roundTripFilter(2, FLT_UP)
|
||||||
|
roundTripFilter(3, FLT_UP)
|
||||||
|
roundTripFilter(4, FLT_UP)
|
||||||
|
|
||||||
|
test "FLT_AVERAGE":
|
||||||
|
roundTripFilter(1, FLT_AVERAGE)
|
||||||
|
roundTripFilter(2, FLT_AVERAGE)
|
||||||
|
roundTripFilter(3, FLT_AVERAGE)
|
||||||
|
roundTripFilter(4, FLT_AVERAGE)
|
||||||
|
|
||||||
|
test "FLT_PAETH":
|
||||||
|
roundTripFilter(1, FLT_PAETH)
|
||||||
|
roundTripFilter(2, FLT_PAETH)
|
||||||
|
roundTripFilter(3, FLT_PAETH)
|
||||||
|
roundTripFilter(4, FLT_PAETH)
|
||||||
|
|
||||||
|
test "FLT_NONE with prevLine":
|
||||||
|
roundTripFilterP(1, FLT_NONE)
|
||||||
|
roundTripFilterP(2, FLT_NONE)
|
||||||
|
roundTripFilterP(3, FLT_NONE)
|
||||||
|
roundTripFilterP(4, FLT_NONE)
|
||||||
|
|
||||||
|
test "FLT_SUB with prevLine":
|
||||||
|
roundTripFilterP(1, FLT_SUB)
|
||||||
|
roundTripFilterP(2, FLT_SUB)
|
||||||
|
roundTripFilterP(3, FLT_SUB)
|
||||||
|
roundTripFilterP(4, FLT_SUB)
|
||||||
|
|
||||||
|
test "FLT_UP with prevLine":
|
||||||
|
roundTripFilterP(1, FLT_UP)
|
||||||
|
roundTripFilterP(2, FLT_UP)
|
||||||
|
roundTripFilterP(3, FLT_UP)
|
||||||
|
roundTripFilterP(4, FLT_UP)
|
||||||
|
|
||||||
|
test "FLT_AVERAGE with prevLine":
|
||||||
|
roundTripFilterP(1, FLT_AVERAGE)
|
||||||
|
roundTripFilterP(2, FLT_AVERAGE)
|
||||||
|
roundTripFilterP(3, FLT_AVERAGE)
|
||||||
|
roundTripFilterP(4, FLT_AVERAGE)
|
||||||
|
|
||||||
|
test "FLT_PAETH with prevLine":
|
||||||
|
roundTripFilterP(1, FLT_PAETH)
|
||||||
|
roundTripFilterP(2, FLT_PAETH)
|
||||||
|
roundTripFilterP(3, FLT_PAETH)
|
||||||
|
roundTripFilterP(4, FLT_PAETH)
|
||||||
|
|
||||||
|
#of LFS_ZERO: filterZero(output, input, w, h, bpp)
|
||||||
|
#of LFS_MINSUM: filterMinsum(output, input, w, h, bpp)
|
||||||
|
#of LFS_ENTROPY: filterEntropy(output, input, w, h, bpp)
|
||||||
|
#of LFS_BRUTE_FORCE: filterBruteForce(output, input, w, h, bpp)
|
||||||
|
#of LFS_PREDEFINED: filterPredefined(output, input, w, h, bpp, state)
|
||||||
|
|
||||||
|
proc main() =
|
||||||
|
testFilterScanline()
|
||||||
|
|
||||||
|
main()
|
||||||
|
|
||||||
Loading…
Reference in New Issue