typedef struct {
	uint8_t  R;
	uint8_t  G;
	uint8_t  B;
} PIXEL_INFO;

void FloydSteinbergBinarize(PIXEL_INFO *rgb, uint32_t height, uint32_t width) {
	uint32_t   x, y, pos;
	const uint8_t threshold = 127;
	uint8_t    bw, luminance;
	int8_t     *error, e;
	PIXEL_INFO *imgpt;
	error = (int8_t *)malloc(width * height);
	memset(error,0x00,width * height);

	imgpt = rgb;
	for (y=0; y < height; y++) {
		for (x=0; x < width; x++) {
			pos = width * y + x;
			luminance = imgpt->R + error[pos];
			if (threshold < luminance) {
				bw = 255;
			} else {
				bw = 0;
			}
			e = luminance - bw;

			if ((x+1)<width) {
				pos = width * y + (x + 1);
				error[pos] += (uint8_t)(e * 7/16);
			}
			if ( ((x-1)>=0) && ((y+1)<height) ) {
				pos = width * (y + 1) + (x - 1);
				error[pos] += (uint8_t)(e * 3/16);
			}
			if ((y+1)<height) {
				pos = width * (y + 1) + x;
				error[pos] += (uint8_t)(e * 5/16);
			}
			if ( ((x+1)<width) && ((y+1)<height) ) {
				pos = width * (y + 1) + (x + 1);
				error[pos] += (uint8_t)(e * 1/16);
			}
			imgpt->G = bw;
			imgpt++;
		}
	}
	free(error);

	imgpt = rgb;
	for (y=0; y < height; y++) {
		for (x=0; x < width; x++) {
			imgpt->R = imgpt->G;
			imgpt->B = imgpt->G;
			imgpt++;
		}
	}
}

void shiftBit(IMAGE_INFO *img, uint8_t sR, uint8_t sG, uint8_t sB) {

	int        x,y;
	PIXEL_INFO *imgpt;

	imgpt = img->RGBs;
	for(y=0; y < img->Height; y++){
		for(x=0; x < img->Width; x++){
			imgpt->B = imgpt->B >> sB;
			imgpt->G = imgpt->G >> sG;
			imgpt->R = imgpt->R >> sR;
			imgpt++;
		}
	}
}

void gammaCorrect(PIXEL_INFO *rgb, uint32_t height, uint32_t width, float gamma) {

	uint32_t   x, y;
	float      Rval, Gval, Bval;
	for(y=0; y < height; y++){
		for(x=0; x < width; x++){
			Rval = (float)rgb->R / 255;
			Gval = (float)rgb->G / 255;
			Bval = (float)rgb->B / 255;
			rgb->R = (uint8_t)(pow(Rval,gamma) * 255);
			rgb->G = (uint8_t)(pow(Gval,gamma) * 255);
			rgb->B = (uint8_t)(pow(Bval,gamma) * 255);
			rgb++;
		}
	}
}

gammaCorrect(img->RGBs, img->Height, img->Width, 2.2);