Reducing size of image pixel data to display in window

I need help figuring out how to reduce the size of an image and display it in a window. Here's what I have so far:

Code:

char *buffer;
int x,y;
int image_width = 1920;
int image_height = 1080;
int preview_width = 304;
int preview_height = 176;
int num_channels = 3; //may be 4 if alpha channel is present
int pixeldata;
int pixelout[4]; //may hold 3 or 4 8-bit pixel values

float calc_width = ((float)img_width/(float)preview_width);
float calc_height = ((float)img_height/(float)preview_height);

float pixelcounter = 0;

for(y=0; y<preview_height; y++){
	for(x=0; x<preview_width; x++){

		memcpy(&pixeldata,(buffer+(int)pixelcounter),num_channels);
		pixelout[0] = (pixeldata&0x000000FF);		//red
		pixelout[1] = (pixeldata&0x0000FF00)>>8;	//green
		pixelout[2] = (pixeldata&0x00FF0000)>>16;	//blue
		
		//assign bytes to NSBitmapImageRep object
		[nsBitmapImageRepObj setPixel:pixelout atX:x y:y];

		//skip bytes to reduce width
		pixelcounter += (int)calc_width*3;
	}
	//skip bytes to reduce height
	pixelcounter = ((y*(int)calc_height)*(img_width*num_channels));
}

The problem I have is that the preview image gets cut off because the width is divided by an integer and not a float. If I divide it by the float value of calc_width, there is no guarantee that the next read into the buffer will be on the three pixel RGB boundary. The only way to guarantee this is to divide the image by a factor of 3. This works, but then accuracy is compromised.

What I need to do is divide the image width using the float value, then "snap" the result to the nearest red pixel. Making the result a multiple of 3 doesn't work because it just converts calc_width back to an integer.

Sorry if this isn't the best explanation, but hopefully someone will be able to figure out what I'm trying to do!

I just explained this to someone at work last week who was doing a very similar thing with graphics.
Integer divisions lose information (the remainder) but integer multiplications don't (as long as they don't overflow).
One trick then is to perform multiplications before the divisions.
In your case (and the one I described to someone else) your multiplications are being done through successive additions. Those are your additions to pixelcounter.

Instead of performing multiplications via successive additions, you can just perform a multiplication:
E.g. Replace this line

Code:

memcpy(&pixeldata,(buffer+(int)pixelcounter),num_channels);

with just this

Code:

memcpy(&pixeldata, (buffer +
    (y*preview_height/img_height)*(img_width*num_channels) +
    (x*preview_width/img_width)*3), num_channels);

and remove the no-longer-necessary code dealing with pixelcounter.
Now this will generate correct results and you can reapply the optimisation techniques you know such as loop-hoisting to get a faster solution from there.

It can be done without the divisions inside the loops if you do some research, but don't trying doing that before you know how to get it to work at all.
So yeah this is also a lesson in "get it working first, then get it fast".

Note that in a final solution I would recommend getting rid of the memcpy and just accessing the three bytes consecutive from the address calculated. This removes endian issues and removes one cause of the slowdown.

Did you know that you can get a much better image by averaging groups of pixels instead of just skipping them? You can also perform bilinear filtering or similar to improve the image quality. There's also http://en.wikipedia.org/wiki/Lanczos_resampling if you get really enthusiastic!

Awesome. That totally worked! Here's my new loop:

Code:

for(y=0; y<preview_height; y++){
	for(x=0; x<preview_width; x++){
			
		memcpy(&pixeldata, buffer+(
			((y*img_height/preview_height) * (img_width*num_channels)) +
			( x*img_width/preview_width)   *  num_channels), num_channels);
						 
		pixelout[0] = (pixeldata&0x000000FF);		//red
		pixelout[1] = (pixeldata&0x0000FF00)>>8;	//green
		pixelout[2] = (pixeldata&0x00FF0000)>>16;	//blue
		
		//populate bitmap
		[nsBitmapImageRepObj setPixel:pixelout atX:x y:y];	
	}
}

The code is much cleaner, too. Thanks!