dithering.cpp File Reference

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <QVarLengthArray>

Go to the source code of this file.

Macros
#define	ACCUMULATE(accumulator, x, y, width, v)   if (x < width && x >= 0) accumulator[(y * width) + x] += v
#define	CLAMP_256(v)   if (v > 255) v = 255; if (v < 0) v = 0;
#define	CONVERT_8BIT_TO_4BIT(v)   (lookup_8bit_to_4bit[v])
#define	DIFF_8BIT_TO_4BIT(v)   (lookup_8bit_to_4bit_diff[v])
#define	GET_RGBA_COMPONENT(data, x, y, stride, c)   (data[(y * stride) + (x << 2) + c])
#define	PUT_4444(data, x, y, width, r, g, b, a)   (data[(y * width) + x] = (r << 12) | (g << 8) | (b << 4) | a)
#define	PUT_565(data, x, y, width, r, g, b)   (data[(y * width) + x] = (r << 11) | (g << 5) | b)

Functions
unsigned short *	convertARGB32_to_RGBA4444 (const unsigned char *in, int width, int height, int stride)
unsigned char *	convertBGRA32_to_RGBA32 (const unsigned char *in, int width, int height, int stride)
unsigned short *	convertRGB32_to_RGB565 (const unsigned char *in, int width, int height, int stride)

Macro Definition Documentation

ACCUMULATE

#define ACCUMULATE	(		accumulator,
			x,
			y,
			width,
			v
	)		if (x < width && x >= 0) accumulator[(y * width) + x] += v

Definition at line 78 of file dithering.cpp.

Referenced by convertARGB32_to_RGBA4444().

CLAMP_256

#define CLAMP_256

(

v

)

if (v > 255) v = 255; if (v < 0) v = 0;

Definition at line 81 of file dithering.cpp.

Referenced by convertARGB32_to_RGBA4444().

CONVERT_8BIT_TO_4BIT

#define CONVERT_8BIT_TO_4BIT

(

v

)

(lookup_8bit_to_4bit[v])

Referenced by convertARGB32_to_RGBA4444().

DIFF_8BIT_TO_4BIT

#define DIFF_8BIT_TO_4BIT

(

v

)

(lookup_8bit_to_4bit_diff[v])

Referenced by convertARGB32_to_RGBA4444().

GET_RGBA_COMPONENT

#define GET_RGBA_COMPONENT	(		data,
			x,
			y,
			stride,
			c
	)		(data[(y * stride) + (x << 2) + c])

Definition at line 68 of file dithering.cpp.

Referenced by convertARGB32_to_RGBA4444(), and convertRGB32_to_RGB565().

PUT_4444

#define PUT_4444	(		data,
			x,
			y,
			width,
			r,
			g,
			b,
			a
	)		(data[(y * width) + x] = (r << 12) | (g << 8) | (b << 4) | a)

Definition at line 74 of file dithering.cpp.

Referenced by convertARGB32_to_RGBA4444().

PUT_565

#define PUT_565	(		data,
			x,
			y,
			width,
			r,
			g,
			b
	)		(data[(y * width) + x] = (r << 11) | (g << 5) | b)

Definition at line 71 of file dithering.cpp.

Referenced by convertRGB32_to_RGB565().

Function Documentation

convertARGB32_to_RGBA4444()

unsigned short* convertARGB32_to_RGBA4444	(	const unsigned char *	in,
		int	width,
		int	height,
		int	stride
	)

Definition at line 152 of file dithering.cpp.

{
    // Output line stride. Aligned to 4 bytes.
    int alignedWidth = width;
    if (alignedWidth % 2 > 0)
        alignedWidth++;

    // Will store output
    unsigned short *out = (unsigned short *) malloc(alignedWidth * 2 * height);

    // Lookup tables for the 8bit => 4bit conversion
    unsigned char lookup_8bit_to_4bit[256];
    short lookup_8bit_to_4bit_diff[256];

    // Macros for the conversion using the lookup table.
    #define CONVERT_8BIT_TO_4BIT(v) (lookup_8bit_to_4bit[v])
    #define DIFF_8BIT_TO_4BIT(v) (lookup_8bit_to_4bit_diff[v])

    int i;
    int x, y, c; // Pixel we're processing. c is component number (0, 1, 2, 3 for r, b, b, a)
    short component[4]; // Stores the new components (r, g, b, a) for pixel produced during conversion
    short diff; // The difference between the converted value and the original one. To be accumulated.
    QVarLengthArray <short> accumulatorData(4 * width * 2); // Data for three acumulators for r, g, b. Each accumulator is two lines.
    short *accumulator[4]; // Helper for accessing the accumulator on a per-channel basis more easily.
    accumulator[0] = accumulatorData.data();
    accumulator[1] = accumulatorData.data() + width;
    accumulator[2] = accumulatorData.data() + (width * 2);
    accumulator[3] = accumulatorData.data() + (width * 3);

    // Produce the conversion lookup tables.
    for (i = 0; i < 256; i++) {
        lookup_8bit_to_4bit[i] = round(i / 16.0);
        // Before bitshifts: (i * 8) - (... * 16 * 8)
        lookup_8bit_to_4bit_diff[i] = (i << 3) - (lookup_8bit_to_4bit[i] << 7);

        if (lookup_8bit_to_4bit[i] > 15)
            lookup_8bit_to_4bit[i] = 15;
    }

    // Clear the accumulators
    memset(accumulator[0], 0, width * 4);
    memset(accumulator[1], 0, width * 4);
    memset(accumulator[2], 0, width * 4);
    memset(accumulator[3], 0, width * 4);

    // For each line...
    for (y = 0; y < height; y++) {

        // For each component (r, g, b, a)...
        memcpy(accumulator[0], accumulator[0] + width, width * 2);
        memset(accumulator[0] + width, 0, width * 2);

        memcpy(accumulator[1], accumulator[1] + width, width * 2);
        memset(accumulator[1] + width, 0, width * 2);

        memcpy(accumulator[2], accumulator[2] + width, width * 2);
        memset(accumulator[2] + width, 0, width * 2);

        memcpy(accumulator[3], accumulator[3] + width, width * 2);
        memset(accumulator[3] + width, 0, width * 2);

        // For each column....
        for (x = 0; x < width; x++) {

            // For each component (r, g, b, a)...
            for (c = 0; c < 4; c++) {

                // Get the 8bit value from the original image
                component[c] = GET_RGBA_COMPONENT(in, x, y, stride, c);

                // Add the diffusion for this pixel we stored in the accumulator.
                // >> 7 because the values in accumulator are stored * 128
                component[c] += accumulator[c][x] >> 7;

                // Make sure we're not over the boundaries.
                CLAMP_256(component[c]);

                // Store the difference from converting 8bit => 4bit and the orig pixel.
                // Convert 8bit => 4bit.
                diff = DIFF_8BIT_TO_4BIT(component[c]);
                component[c] = CONVERT_8BIT_TO_4BIT(component[c]);

                // Distribute the difference according to the matrix in the
                // accumulation bufffer.
                ACCUMULATE(accumulator[c], x + 1, 0, width, diff * 7);
                ACCUMULATE(accumulator[c], x - 1, 1, width, diff * 3);
                ACCUMULATE(accumulator[c], x, 1, width, diff * 5);
                ACCUMULATE(accumulator[c], x + 1, 1, width, diff * 1);
            }

            // Write the newly produced pixel
            PUT_4444(out, x, y, alignedWidth, component[0], component[1], component[2], component[3]);
        }
    }

    return out;
}

convertBGRA32_to_RGBA32()

unsigned char* convertBGRA32_to_RGBA32	(	const unsigned char *	in,
		int	width,
		int	height,
		int	stride
	)

Definition at line 250 of file dithering.cpp.

Referenced by QMeeGoPixmapData::imageToEGLSharedImage().

{
    unsigned char *out = (unsigned char *) malloc(stride * height);

    // For each line...
    for (int y = 0; y < height; y++) {
        // For each column
        for (int x = 0; x < width; x++) {
            out[(stride * y) + (x * 4) + 0] = in[(stride * y) + (x * 4) + 2];
            out[(stride * y) + (x * 4) + 1] = in[(stride * y) + (x * 4) + 1];
            out[(stride * y) + (x * 4) + 2] = in[(stride * y) + (x * 4) + 0];
            out[(stride * y) + (x * 4) + 3] = in[(stride * y) + (x * 4) + 3];
        }
    }

    return out;
}

convertRGB32_to_RGB565()

unsigned short* convertRGB32_to_RGB565	(	const unsigned char *	in,
		int	width,
		int	height,
		int	stride
	)

Definition at line 84 of file dithering.cpp.

Referenced by QMeeGoPixmapData::imageToEGLSharedImage().

{
    static bool thresholdMapInitialized = false;
    static int thresholdMap[16][16];

    if (!thresholdMapInitialized) {
        int i;
        int j;
        int n;

        thresholdMap[0][0] = 0;
        thresholdMap[1][0] = 2;
        thresholdMap[0][1] = 3;
        thresholdMap[1][1] = 1;

        for (n=2; n<16; n*=2) {
            for (i=0; i<n; i++) {
                for (j=0; j<n; j++) {
                    thresholdMap[i][j]    *= 4;
                    thresholdMap[i+n][j]   = thresholdMap[i][j] + 2;
                    thresholdMap[i][j+n]   = thresholdMap[i][j] + 3;
                    thresholdMap[i+n][j+n] = thresholdMap[i][j] + 1;
                }
            }
        }

        thresholdMapInitialized = true;
    }

    // Output line stride. Aligned to 4 bytes.
    int alignedWidth = width;
    if (alignedWidth % 2 > 0)
        alignedWidth++;

    // Will store output
    unsigned short *out = (unsigned short *)malloc (alignedWidth * height * 2);

    int x;
    int y;
    int threshold;

    // For each line...
    for (y = 0; y < height; y++) {

        // For each column....
        for (x = 0; x < width; x++) {

            int r = GET_RGBA_COMPONENT(in, x, y, stride, 0);
            int g = GET_RGBA_COMPONENT(in, x, y, stride, 1);
            int b = GET_RGBA_COMPONENT(in, x, y, stride, 2);

            threshold = thresholdMap[x%16][y%16];

            if (r <= (255-(1<<3)) && ((r<<5) & 255) > threshold) r += (1<<3);
            if (g <= (255-(1<<2)) && ((g<<6) & 255) > threshold) g += (1<<2);
            if (b <= (255-(1<<3)) && ((b<<5) & 255) > threshold) b += (1<<3);

            // Write the newly produced pixel
            PUT_565(out, x, y, alignedWidth, ((b >> 3) & 0x1f), ((g >> 2) & 0x3f), ((r >> 3) & 0x1f));
        }
    }

    return out;
}