Question

Because I’m masochistic I’m trying to write something in C to decode an 8-bit PNG file (it’s a learning thing, I’m not trying to reinvent libpng…)

I’ve got to the point when the stuff in my deflated, unfiltered data buffer unmistakably resembles the source image (see below), but it’s still quite, erm, wrong, and I’m pretty sure there’s something askew with my implementation of the filtering algorithms. Most of them are quite simple, but there’s one major thing I don’t understand in the docs, not being good at maths or ever having taken a comp-sci course:

Unsigned arithmetic modulo 256 is used, so that both the inputs and outputs fit into bytes.

What does that mean?

If someone can tell me that I’d be very grateful!

For reference, (and I apologise for the crappy C) my noddy implementation of the filtering algorithms described in the docs look like:

unsigned char paeth_predictor (unsigned char a, unsigned char b, unsigned char c) {
    // a = left, b = above, c = upper left
    char p = a + b - c; //  initial estimate
    char pa = abs(p - a);    //  distances to a, b, c
    char pb = abs(p - b);
    char pc = abs(p - c);
    // return nearest of a,b,c,
    // breaking ties in order a,b,c.
    if (pa <= pb && pa <= pc) return a;
    else if (pb <= pc) return b;
    else return c;
}

void unfilter_sub(char* out, char* in, int bpp, int row, int rowlen) {
    for (int i = 0; i < rowlen; i++)
        out[i] = in[i] + (i < bpp ? 0 : out[i-bpp]);
}

void unfilter_up(char* out, char* in, int bpp, int row, int rowlen) {
    for (int i = 0; i < rowlen; i++)
        out[i] = in[i] + (row == 0 ? 0 : out[i-rowlen]);
}

void unfilter_paeth(char* out, char* in, int bpp, int row, int rowlen) {
    char a, b, c;
    for (int i = 0; i < rowlen; i++) {
        a = i < bpp ? 0 : out[i - bpp];
        b = row < 1 ? 0 : out[i - rowlen];
        c = i < bpp ? 0 : (row == 0 ? 0 : out[i - rowlen - bpp]);
        out[i] = in[i] + paeth_predictor(a, b, c);
    }
}              

And the images I’m seeing:

Source

Source http://img220.imageshack.us/img220/8111/testdn.png

Output

Output http://img862.imageshack.us/img862/2963/helloworld.png

Answer 1

It means that, in the algorithm, whenever an arithmetic operation is performed, it is performed modulo 256, i.e. if the result is greater than 256 then it “wraps” around. The result is that all values will always fit into 8 bits and not overflow.

Unsigned types already behave this way by mandate, and if you use unsigned char (and a byte on your system is 8 bits, which it probably is), then your calculation results will naturally just never overflow beyond 8 bits.