Bilinear Interpolation image resizing marks & 'splotches' - c

Question

I'm making an image resizing program in C and at the moment I'm having trouble with the Bilinear Interpolation function (it's one of many I'm using). This problem only arises for 16-bit bitmaps, If I use 24-bit versions, it resizes them perfectly.
Here's my code for the Bilinear Interpolation. n_w and n_h are the new widths and heights of the image:
#define getelm(x) (((pix+index)->x)*(1-xdiff)*(1-ydiff))+(((pix+index+1)->x)*(xdiff)*(1-ydiff))+(((pix+index+o_w)->x)*(1-xdiff)*(ydiff))+((pix+index+o_w+1)->x)*xdiff*ydiff
int pad = (2*n_w) & 3;
if (pad)
pad = 4-pad;
uint16_t *buffer;
if (buf)
buffer = malloc(2*n_w);
for (i = 0; i < n_h; i++) {
for (j = 0; j < n_w; j++) {
x = (int)(j*xrat);
y = (int)(i*yrat);
xdiff = (xrat*j)-x;
ydiff = (yrat*i)-y;
index = y*o_w+x;
uint16_t container = 0;
container |= (int)(round(getelm(b))) << 11;
container |= (int)(round(getelm(g))) << 5;
container |= (int)round(getelm(r));
if (buf)
*(buffer+j) = container;
else
fwrite(&container, 1, 2, dest);
}
if (buf)
fwrite(buffer, 1, 2*n_w, dest);
fwrite(&pad, 1, pad, dest);
}
My 24-bit version of this code (where the only difference is that the container is not used and instead 3 8-bit integers hold the RGB values) works beautifully.
This code, however, gives weird results. Look at the image below:
When I resize this, it gives me this back:
I can't see why this would be happening, especially when it works for 24-bit bitmaps, and also that some other resizing algorithms (Nearest Neighbour for example) work with 16-bit in the same way that this should.
EDIT:
I don't think it's an overflow problem, because adding the following code gives no output when run:
if (MAX((int)(getelm(b)), 31) > 31)
printf("blue overflow: %.10f\n", (getelm(b)));
if (MAX((int)(getelm(g)), 63) > 63)
printf("green overflow: %.10f\n", (getelm(g)));
if (MAX((int)(getelm(r)), 31) > 31)
printf("red overflow: %.10f\n", (getelm(r)));
EDIT 2:
I don't think it's an underflow problem either, this does nothing:
if ((getelm(b)) < 0 || (getelm(g)) < 0 || (getelm(r)) < 0)
printf("Underflow\n");

Answer 1

Assuming the data in pix have the type
struct
{
uint16_t r : 5;
uint16_t g : 6;
uint16_t b : 5;
};
there's a bug in the calculation of container. Using round won't always prevent overflow. The next code will:
uint16_t container = 0;
container |= ((int)(round(getelm(b))) & 31) << 11; // optionally
container |= ((int)(round(getelm(g))) & 63) << 5;
container |= ((int)round(getelm(r)) & 31);
or to retain a maximum of the lost information:
uint16_t container = 0;
container |= min((int)(round(getelm(b))) , 31) << 11;
container |= min(((int)(round(getelm(g))) , 63) << 5;
container |= min(((int)round(getelm(r)) , 31);
EDIT
Since pix->r, pix->g and pix->b come from 8bit values, a same reasoning apply to them and their range needs to be checked.
Since a white region turns to purple this means that the green color is suppressed due to overflows or it's read as zero in the first place. In this case inspecting read color can help.
Similarly, a black color turns into green means a bit representing a small value is shifted and the color is somehow inverted.
To find the bug I recommend splitting the code into small functions and asserting the input of each one of them.