Set up CI & produce packages

The Paeth predictor filter is based on 3 neighbors: left, up, and up and left. The

Paeth(x) = Raw(x) - PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))

Prior and Raw are defined the same way as in the other predictors. All math must be done exactly, without overflow, except for the final step of subtracting the Paeth predictor value from the Raw value.

The predictor pseudocode is as follows:

function PaethPredictor (a, b, c)
   begin
        ; a = left, b = above, c = upper left
        p := a + b - c        ; initial estimate
        pa := abs(p - a)      ; distances to a, b, c
        pb := abs(p - b)
        pc := abs(p - c)
        ; return nearest of a,b,c,
        ; breaking ties in order a,b,c.
        if pa <= pb AND pa <= pc then return a
        else if pb <= pc then return b
        else return c
   end

The tiebreak order is important. To reverse the order, apply the following calculation:

Paeth(x) + PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))

The same predictor function is used.

Right now we're writing them in little-endian. Oops.

Section 4.3.2 of the standard says that encoders should, as part of encoding, implement alpha separation as follows: "If all alpha samples in a reference image have the maximum value, then the alpha channel may be omitted, resulting in an equivalent image that can be encoded more compactly."

4.3.5 Alpha compaction

For non-indexed images, if there exists an RGB (or greyscale) value such that all pixels with that value
are fully transparent while all other pixels are fully opaque, then the alpha channel can be represented
more compactly by merely identifying the RGB (or greyscale) value that is transparent.

This allows you to transform an image type with alpha into one without it if there is a fully transparent RGB/grayscale value by writing an image w/o an alpha channel and then using a tRNS chunk to indicate the transparent value. See 4.2.1.1. tRNS Transparency.

The Sub filter is filter type 1, and operates as follows:

Sub(x) = Raw(x) - Raw(x - bpp)

For the first pixel in any given scanline, Sub(x) does not wrap around and Raw(x - bpp) is assumed to be 0.

To restore the value, calculate Sub(x) + Raw(x - bpp).

Section 4.3.4 of the standard, RGB merging:

"If the red, green, and blue channels have the same sample depth, and for each pixel the values of the red, green, and blue samples are equal, then these three channels may be merged into a single greyscale channel."

We already support grayscale conversions via Color.

The Up filter is filter type 2, and operates as follows:

Up(x) = Raw(x) - Prior(x)

For any byte in the first scanline, Prior(x) is 0, otherwise it's byte x in the previous scanline. Arithmetic is unsigned, done modulo 256.

To restore the pixel value, calculate Up(x) + Prior(x)

In deb9423, I changed the API to be FilterInto rather than Filter. Upon some reflection, it might be better to have Filter do the allocation, and the caller can just write the single filter type byte directly to the compressed stream. It should be buffering, so WriteByte won't kill performance.

It's almost certainly more optimized than ours, and is BSD licensed, so we can freely use it.

https://github.com/dotnet/corefx/blob/master/src/System.IO.Compression/src/System/IO/Compression/Crc32Helper.cs

The Avg filter is filter type 3, and operates as follows:

Average(x) = Raw(x) - floor((Raw(x-bpp)+Prior(x))/2)

Raw(x-bpp) and Prior(x) are defined as in the Sub and Up filters

To restore the pixel value, calculate Average(x) + floor((Raw(x-bpp)+Prior(x))/2).