Function filter

dependency/densecrf/examples/lodepng.cpp:5203–5421

}

static unsigned filter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h,
                       const LodePNGColorMode* info, const LodePNGEncoderSettings* settings)
{
    /*
     For PNG filter method 0
     out must be a buffer with as size: h + (w * h * bpp + 7) / 8, because there are
     the scanlines with 1 extra byte per scanline
     */
    
    unsigned bpp = lodepng_get_bpp(info);
    /*the width of a scanline in bytes, not including the filter type*/
    size_t linebytes = (w * bpp + 7) / 8;
    /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
    size_t bytewidth = (bpp + 7) / 8;
    const unsigned char* prevline = 0;
    unsigned x, y;
    unsigned error = 0;
    LodePNGFilterStrategy strategy = settings->filter_strategy;
    
    /*
     There is a heuristic called the minimum sum of absolute differences heuristic, suggested by the PNG standard:
     *  If the image type is Palette, or the bit depth is smaller than 8, then do not filter the image (i.e.
     use fixed filtering, with the filter None).
     * (The other case) If the image type is Grayscale or RGB (with or without Alpha), and the bit depth is
     not smaller than 8, then use adaptive filtering heuristic as follows: independently for each row, apply
     all five filters and select the filter that produces the smallest sum of absolute values per row.
     This heuristic is used if filter strategy is LFS_MINSUM and filter_palette_zero is true.
     
     If filter_palette_zero is true and filter_strategy is not LFS_MINSUM, the above heuristic is followed,
     but for "the other case", whatever strategy filter_strategy is set to instead of the minimum sum
     heuristic is used.
     */
    if(settings->filter_palette_zero &&
       (info->colortype == LCT_PALETTE || info->bitdepth < 8)) strategy = LFS_ZERO;
    
    if(bpp == 0) return 31; /*error: invalid color type*/
    
    if(strategy == LFS_ZERO)
    {
        for(y = 0; y != h; ++y)
        {
            size_t outindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
            size_t inindex = linebytes * y;
            out[outindex] = 0; /*filter type byte*/
            filterScanline(&out[outindex + 1], &in[inindex], prevline, linebytes, bytewidth, 0);
            prevline = &in[inindex];
        }
    }
    else if(strategy == LFS_MINSUM)
    {
        /*adaptive filtering*/
        size_t sum[5];
        unsigned char* attempt[5]; /*five filtering attempts, one for each filter type*/
        size_t smallest = 0;
        unsigned char type, bestType = 0;
        
        for(type = 0; type != 5; ++type)
        {