/*====================================================================*
- Copyright (C) 2001 Leptonica. All rights reserved.
- This software is distributed in the hope that it will be
- useful, but with NO WARRANTY OF ANY KIND.
- No author or distributor accepts responsibility to anyone for the
- consequences of using this software, or for whether it serves any
- particular purpose or works at all, unless he or she says so in
- writing. Everyone is granted permission to copy, modify and
- redistribute this source code, for commercial or non-commercial
- purposes, with the following restrictions: (1) the origin of this
- source code must not be misrepresented; (2) modified versions must
- be plainly marked as such; and (3) this notice may not be removed
- or altered from any source or modified source distribution.
*====================================================================*/
/*
* grayquantlow.c
*
* Thresholding from 8 bpp to 1 bpp
*
* Floyd-Steinberg dithering to binary
* void ditherToBinaryLow()
* void ditherToBinaryLineLow()
*
* Simple (pixelwise) binarization
* void thresholdToBinaryLow()
* void thresholdToBinaryLineLow()
*
* A slower version of Floyd-Steinberg dithering that uses LUTs
* void ditherToBinaryLUTLow()
* void ditherToBinaryLineLUTLow()
* l_int32 make8To1DitherTables()
*
* Thresholding from 8 bpp to 2 bpp
*
* Floyd-Steinberg-like dithering to 2 bpp
* void ditherTo2bppLow()
* void ditherTo2bppLineLow()
* l_int32 make8To2DitherTables()
*
* Simple thresholding to 2 bpp
* void thresholdTo2bppLow()
*
* Thresholding from 8 bpp to 4 bpp
*
* Simple thresholding to 4 bpp
* void thresholdTo4bppLow()
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "allheaders.h"
#ifndef NO_CONSOLE_IO
#define DEBUG_UNROLLING 0
#endif /* ~NO_CONSOLE_IO */
/*------------------------------------------------------------------*
* Binarization by Floyd-Steinberg Dithering *
*------------------------------------------------------------------*/
/*
* ditherToBinaryLow()
*
* See comments in pixDitherToBinary() in binarize.c
*/
void
ditherToBinaryLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_uint32 *bufs1,
l_uint32 *bufs2,
l_int32 lowerclip,
l_int32 upperclip)
{
l_int32 i;
l_uint32 *lined;
/* do all lines except last line */
memcpy(bufs2, datas, 4 * wpls); /* prime the buffer */
for (i = 0; i < h - 1; i++) {
memcpy(bufs1, bufs2, 4 * wpls);
memcpy(bufs2, datas + (i + 1) * wpls, 4 * wpls);
lined = datad + i * wpld;
ditherToBinaryLineLow(lined, w, bufs1, bufs2, lowerclip, upperclip, 0);
}
/* do last line */
memcpy(bufs1, bufs2, 4 * wpls);
lined = datad + (h - 1) * wpld;
ditherToBinaryLineLow(lined, w, bufs1, bufs2, lowerclip, upperclip, 1);
return;
}
/*
* ditherToBinaryLineLow()
*
* Input: lined (ptr to beginning of dest line
* w (width of image in pixels)
* bufs1 (buffer of current source line)
* bufs2 (buffer of next source line)
* lowerclip (lower clip distance to black)
* upperclip (upper clip distance to white)
* lastlineflag (0 if not last dest line, 1 if last dest line)
* Return: void
*
* Dispatches FS error diffusion dithering for
* a single line of the image. If lastlineflag == 0,
* both source buffers are used; otherwise, only bufs1
* is used. We use source buffers because the error
* is propagated into them, and we don't want to change
* the input src image.
*
* We break dithering out line by line to make it
* easier to combine functions like interpolative
* scaling and error diffusion dithering, as such a
* combination of operations obviates the need to
* generate a 2x grayscale image as an intermediary.
*/
void
ditherToBinaryLineLow(l_uint32 *lined,
l_int32 w,
l_uint32 *bufs1,
l_uint32 *bufs2,
l_int32 lowerclip,
l_int32 upperclip,
l_int32 lastlineflag)
{
l_int32 j;
l_int32 oval, eval;
l_uint8 fval1, fval2, rval, bval, dval;
if (lastlineflag == 0) {
for (j = 0; j < w - 1; j++) {
oval = GET_DATA_BYTE(bufs1, j);
if (oval > 127) { /* binarize to OFF */
if ((eval = 255 - oval) > upperclip) {
/* subtract from neighbors */
fval1 = (3 * eval) / 8;
fval2 = eval / 4;
rval = GET_DATA_BYTE(bufs1, j + 1);
rval = L_MAX(0, rval - fval1);
SET_DATA_BYTE(bufs1, j + 1, rval);
bval = GET_DATA_BYTE(bufs2, j);
bval = L_MAX(0, bval - fval1);
SET_DATA_BYTE(bufs2, j, bval);
dval = GET_DATA_BYTE(bufs2, j + 1);
dval = L_MAX(0, dval - fval2);
SET_DATA_BYTE(bufs2, j + 1, dval);
}
}
else { /* oval <= 127; binarize to ON */
SET_DATA_BIT(lined, j); /* ON pixel */
if (oval > lowerclip) {
/* add to neighbors */
fval1 = (3 * oval) / 8;
fval2 = oval / 4;
rval = GET_DATA_BYTE(bufs1, j + 1);
rval = L_MIN(255, rval + fval1);
SET_DATA_BYTE(bufs1, j + 1, rval);
bval = GET_DATA_BYTE(bufs2, j);
bval = L_MIN(255, bval + fval1);
SET_DATA_BYTE(bufs2, j, bval);
dval = GET_DATA_BYTE(bufs2, j + 1);
dval = L_MIN(255, dval + fval2);
SET_DATA_BYTE(bufs2, j + 1, dval);
}
}
}
/* do last column: j = w - 1 */
oval = GET_DATA_BYTE(bufs1, j);
if (oval > 127) { /* binarize to OFF */
if ((eval = 255 - oval) > upperclip) {
/* subtract from neighbors */
fval1 = (3 * eval) / 8;
bval = GET_DATA_BYTE(bufs2, j);
bval = L_MAX(0, bval - fval1);
SET_DATA_BYTE(bufs2, j, bval);
}
}
else { /*oval <= 127; binarize to ON */
SET_DATA_BIT(lined, j); /* ON pixel */
if (oval > lowerclip) {
/* add to neighbors */
fval1 = (3 * oval) / 8;
bval = GET_DATA_BYTE(bufs2, j);
bval = L_MIN(255, bval + fval1);
SET_DATA_BYTE(bufs2, j, bval);
}
}
}
else { /* lastlineflag == 1 */
for (j = 0; j < w - 1; j++) {
oval = GET_DATA_BYTE(bufs1, j);
if (oval > 127) { /* binarize to OFF */
if ((eval = 255 - oval) > upperclip) {
/* subtract from neighbors */
fval1 = (3 * eval) / 8;
rval = GET_DATA_BYTE(bufs1, j + 1);
rval = L_MAX(0, rval - fval1);
SET_DATA_BYTE(bufs1, j + 1, rval);
}
}
else { /* oval <= 127; binarize to ON */
SET_DATA_BIT(lined, j); /* ON pixel */
if (oval > lowerclip) {
/* add to neighbors */
fval1 = (3 * oval) / 8;
rval = GET_DATA_BYTE(bufs1, j + 1);
rval = L_MIN(255, rval + fval1);
SET_DATA_BYTE(bufs1, j + 1, rval);
}
}
}
/* do last pixel: (i, j) = (h - 1, w - 1) */
oval = GET_DATA_BYTE(bufs1, j);
if (oval < 128)
SET_DATA_BIT(lined, j); /* ON pixel */
}
return;
}
/*------------------------------------------------------------------*
* Simple binarization with fixed threshold *
*------------------------------------------------------------------*/
/*
* thresholdToBinaryLow()
*
* If the source pixel is less than thresh,
* the dest will be 1; otherwise, it will be 0
*/
void
thresholdToBinaryLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 d,
l_int32 wpls,
l_int32 thresh)
{
l_int32 i;
l_uint32 *lines, *lined;
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
thresholdToBinaryLineLow(lined, w, lines, d, thresh);
}
return;
}
/*
* thresholdToBinaryLineLow()
*
*/
void
thresholdToBinaryLineLow(l_uint32 *lined,
l_int32 w,
l_uint32 *lines,
l_int32 d,
l_int32 thresh)
{
l_int32 j, k, gval, scount, dcount;
l_uint32 sword, dword;
PROCNAME("thresholdToBinaryLineLow");
switch (d)
{
case 4:
/* Unrolled as 4 source words, 1 dest word */
for (j = 0, scount = 0, dcount = 0; j + 31 < w; j += 32) {
dword = 0;
for (k = 0; k < 4; k++) {
sword = lines[scount++];
dword <<= 8;
gval = (sword >> 28) & 0xf;
/* Trick used here and below: if gval < thresh then
* gval - thresh < 0, so its high-order bit is 1, and
* ((gval - thresh) >> 31) & 1 == 1; likewise, if
* gval >= thresh, then ((gval - thresh) >> 31) & 1 == 0
* Doing it this way avoids a random (and thus easily
* mispredicted) branch on each pixel. */
dword |= ((gval - thresh) >> 24) & 128;
gval = (sword >> 24) & 0xf;
dword |= ((gval - thresh) >> 25) & 64;
gval = (sword >> 20) & 0xf;
dword |= ((gval - thresh) >> 26) & 32;
gval = (sword >> 16) & 0xf;
dword |= ((gval - thresh) >> 27) & 16;
gval = (sword >> 12) & 0xf;
dword |= ((gval - thresh) >> 28) & 8;
gval = (sword >> 8) & 0xf;
dword |= ((gval - thresh) >> 29) & 4;
gval = (sword >> 4) & 0xf;
dword |= ((gval - thresh) >> 30) & 2;
gval = sword & 0xf;
dword |= ((gval - thresh) >> 31) & 1;
}
lined[dcount++] = dword;
}
if (j < w) {
dword = 0;
for (; j < w; j++) {
if ((j & 7) == 0) {
sword = lines[scount++];
}
gval = (sword >> 28) & 0xf;
sword <<= 4;
dword |= (((gval - thresh) >> 31) & 1) << (31 - (j & 31));
}
lined[dcount] = dword;
}
#if DEBUG_UNROLLING
#define CHECK_BIT(a, b, c) if (GET_DATA_BIT(a, b) != c) { \
fprintf(stderr, "Error: mismatch at %d/%d(%d), %d vs %d\n", \
j, w, d, GET_DATA_BIT(a, b), c); }
for (j = 0; j < w; j++) {
gval = GET_DATA_QBIT(lines, j);
CHECK_BIT(lined, j, gval < thresh ? 1 : 0);
}
#endif
break;
case 8:
/* Unrolled as 8 source words, 1 dest word */
for (j = 0, scount = 0, dcount = 0; j + 31 < w; j += 32) {
dword = 0;
for (k = 0; k < 8; k++) {
sword = lines[scount++];
dword <<= 4;
gval = (sword >> 24) & 0xff;
dword |= ((gval - thresh) >> 28) & 8;
gval = (sword >> 16) & 0xff;
dword |= ((gval - thresh) >> 29) & 4;
gval = (sword >> 8) & 0xff;
dword |= ((gval - thresh) >> 30) & 2;
gval = sword & 0xff;
dword |= ((gval - thresh) >> 31) & 1;
}
lined[dcount++] = dword;
}
if (j < w) {
dword = 0;
for (; j < w; j++) {
if ((j & 3) == 0) {
sword = lines[scount++];
}
gval = (sword >> 24) & 0xff;
sword <<= 8;
dword |= (((gval - thresh) >> 31) & 1) << (31 - (j & 31));
}
lined[dcount] = dword;
}
#if DEBUG_UNROLLING
for (j = 0; j < w; j++) {
gval = GET_DATA_BYTE(lines, j);
CHECK_BIT(lined, j, gval < thresh ? 1 : 0);
}
#undef CHECK_BIT
#endif
break;
default:
ERROR_VOID("src depth not 4 or 8 bpp", procName);
break;
}
return;
}
/*---------------------------------------------------------------------*
* Alternate implementation of dithering that uses lookup tables. *
* This is analogous to the method used in dithering to 2 bpp. *
*---------------------------------------------------------------------*/
/*!
* ditherToBinaryLUTLow()
*
* Low-level function for doing Floyd-Steinberg error diffusion
* dithering from 8 bpp (datas) to 1 bpp (datad). Two source
* line buffers, bufs1 and bufs2, are provided, along with three
* 256-entry lookup tables: tabval gives the output pixel value,
* tab38 gives the extra (plus or minus) transferred to the pixels
* directly to the left and below, and tab14 gives the extra
* transferred to the diagonal below. The choice of 3/8 and 1/4
* is traditional but arbitrary when you use a lookup table; the
* only constraint is that the sum is 1. See other comments below.
*/
void
ditherToBinaryLUTLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_uint32 *bufs1,
l_uint32 *bufs2,
l_int32 *tabval,
l_int32 *tab38,
l_int32 *tab14)
{
l_int32 i;
l_uint32 *lined;
/* do all lines except last line */
memcpy(bufs2, datas, 4 * wpls); /* prime the buffer */
for (i = 0; i < h - 1; i++) {
memcpy(bufs1, bufs2, 4 * wpls);
memcpy(bufs2, datas + (i + 1) * wpls, 4 * wpls);
lined = datad + i * wpld;
ditherToBinaryLineLUTLow(lined, w, bufs1, bufs2,
tabval, tab38, tab14, 0);
}
/* do last line */
memcpy(bufs1, bufs2, 4 * wpls);
lined = datad + (h - 1) * wpld;
ditherToBinaryLineLUTLow(lined, w, bufs1, bufs2, tabval, tab38, tab14, 1);
return;
}
/*!
* ditherToBinaryLineLUTLow()
*
* Input: lined (ptr to beginning of dest line
* w (width of image in pixels)
* bufs1 (buffer of current source line)
* bufs2 (buffer of next source line)
* tabval (value to assign for current pixel)
* tab38 (excess value to give to neighboring 3/8 pixels)
* tab14 (excess value to give to neighboring 1/4 pixel)
* lastlineflag (0 if not last dest line, 1 if last dest line)
* Return: void
*/
void
ditherToBinaryLineLUTLow(l_uint32 *lined,
l_int32 w,
l_uint32 *bufs1,
l_uint32 *bufs2,
l_int32 *tabval,
l_int32 *tab38,
l_int32 *tab14,
l_int32 lastlineflag)
{
l_int32 j;
l_int32 oval, tab38val, tab14val;
l_uint8 rval, bval, dval;
if (lastlineflag == 0) {
for (j = 0; j < w - 1; j++) {
oval = GET_DATA_BYTE(bufs1, j);
if (tabval[oval])
SET_DATA_BIT(lined, j);
rval = GET_DATA_BYTE(bufs1, j + 1);
bval = GET_DATA_BYTE(bufs2, j);
dval = GET_DATA_BYTE(bufs2, j + 1);
tab38val = tab38[oval];
if (tab38val == 0)
continue;
tab14val = tab14[oval];
if (tab38val < 0) {
rval = L_MAX(0, rval + tab38val);
bval = L_MAX(0, bval + tab38val);
dval = L_MAX(0, dval + tab14val);
}
else {
rval = L_MIN(255, rval + tab38val);
bval = L_MIN(255, bval + tab38val);
dval = L_MIN(255, dval + tab14val);
}
SET_DATA_BYTE(bufs1, j + 1, rval);
SET_DATA_BYTE(bufs2, j, bval);
SET_DATA_BYTE(bufs2, j + 1, dval);
}
/* do last column: j = w - 1 */
oval = GET_DATA_BYTE(bufs1, j);
if (tabval[oval])
SET_DATA_BIT(lined, j);
bval = GET_DATA_BYTE(bufs2, j);
tab38val = tab38[oval];
if (tab38val < 0) {
bval = L_MAX(0, bval + tab38val);
SET_DATA_BYTE(bufs2, j, bval);
}
else if (tab38val > 0 ) {
bval = L_MIN(255, bval + tab38val);
SET_DATA_BYTE(bufs2, j, bval);
}
}
else { /* lastlineflag == 1 */
for (j = 0; j < w - 1; j++) {
oval = GET_DATA_BYTE(bufs1, j);
if (tabval[oval])
SET_DATA_BIT(lined, j);
rval = GET_DATA_BYTE(bufs1, j + 1);
tab38val = tab38[oval];
if (tab38val == 0)
continue;
if (tab38val < 0)
rval = L_MAX(0, rval + tab38val);
else
rval = L_MIN(255, rval + tab38val);
SET_DATA_BYTE(bufs1, j + 1, rval);
}
/* do last pixel: (i, j) = (h - 1, w - 1) */
oval = GET_DATA_BYTE(bufs1, j);
if (tabval[oval])
SET_DATA_BIT(lined, j);
}
return;
}
/*!
* make8To1DitherTables()
*
* Input: &tabval (value assigned to output pixel; 0 or 1)
* &tab38 (amount propagated to pixels left and below)
* &tab14 (amount propagated to pixel to left and down)
* lowerclip (values near 0 where the excess is not propagated)
* upperclip (values near 255 where the deficit is not propagated)
*
* Return: 0 if OK, 1 on error
*/
l_int32
make8To1DitherTables(l_int32 **ptabval,
l_int32 **ptab38,
l_int32 **ptab14,
l_int32 lowerclip,
l_int32 upperclip)
{
l_int32 i;
l_int32 *tabval, *tab38, *tab14;
PROCNAME("make8To1DitherTables");
if (!ptabval || !ptab38 || !ptab14)
return ERROR_INT("table ptrs not all defined", procName, 1);
/* 3 lookup tables: 1-bit value, (3/8)excess, and (1/4)excess */
if ((tabval = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return ERROR_INT("tabval not made", procName, 1);
if ((tab38 = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return ERROR_INT("tab38 not made", procName, 1);
if ((tab14 = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return ERROR_INT("tab14 not made", procName, 1);
*ptabval = tabval;
*ptab38 = tab38;
*ptab14 = tab14;
for (i = 0; i < 256; i++) {
if (i <= lowerclip) {
tabval[i] = 1;
tab38[i] = 0;
tab14[i] = 0;
}
else if (i < 128) {
tabval[i] = 1;
tab38[i] = (3 * i + 4) / 8;
tab14[i] = (i + 2) / 4;
}
else if (i < 255 - upperclip) {
tabval[i] = 0;
tab38[i] = (3 * (i - 255) + 4) / 8;
tab14[i] = ((i - 255) + 2) / 4;
}
else { /* i >= 255 - upperclip */
tabval[i] = 0;
tab38[i] = 0;
tab14[i] = 0;
}
}
return 0;
}
/*------------------------------------------------------------------*
* Dithering to 2 bpp *
*------------------------------------------------------------------*/
/*
* ditherTo2bppLow()
*
* Low-level function for doing Floyd-Steinberg error diffusion
* dithering from 8 bpp (datas) to 2 bpp (datad). Two source
* line buffers, bufs1 and bufs2, are provided, along with three
* 256-entry lookup tables: tabval gives the output pixel value,
* tab38 gives the extra (plus or minus) transferred to the pixels
* directly to the left and below, and tab14 gives the extra
* transferred to the diagonal below. The choice of 3/8 and 1/4
* is traditional but arbitrary when you use a lookup table; the
* only constraint is that the sum is 1. See other comments
* below and in grayquant.c.
*/
void
ditherTo2bppLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_uint32 *bufs1,
l_uint32 *bufs2,
l_int32 *tabval,
l_int32 *tab38,
l_int32 *tab14)
{
l_int32 i;
l_uint32 *lined;
/* do all lines except last line */
memcpy(bufs2, datas, 4 * wpls); /* prime the buffer */
for (i = 0; i < h - 1; i++) {
memcpy(bufs1, bufs2, 4 * wpls);
memcpy(bufs2, datas + (i + 1) * wpls, 4 * wpls);
lined = datad + i * wpld;
ditherTo2bppLineLow(lined, w, bufs1, bufs2, tabval, tab38, tab14, 0);
}
/* do last line */
memcpy(bufs1, bufs2, 4 * wpls);
lined = datad + (h - 1) * wpld;
ditherTo2bppLineLow(lined, w, bufs1, bufs2, tabval, tab38, tab14, 1);
return;
}
/*
* ditherTo2bppLineLow()
*
* Input: lined (ptr to beginning of dest line
* w (width of image in pixels)
* bufs1 (buffer of current source line)
* bufs2 (buffer of next source line)
* tabval (value to assign for current pixel)
* tab38 (excess value to give to neighboring 3/8 pixels)
* tab14 (excess value to give to neighboring 1/4 pixel)
* lastlineflag (0 if not last dest line, 1 if last dest line)
* Return: void
*
* Dispatches error diffusion dithering for
* a single line of the image. If lastlineflag == 0,
* both source buffers are used; otherwise, only bufs1
* is used. We use source buffers because the error
* is propagated into them, and we don't want to change
* the input src image.
*
* We break dithering out line by line to make it
* easier to combine functions like interpolative
* scaling and error diffusion dithering, as such a
* combination of operations obviates the need to
* generate a 2x grayscale image as an intermediary.
*/
void
ditherTo2bppLineLow(l_uint32 *lined,
l_int32 w,
l_uint32 *bufs1,
l_uint32 *bufs2,
l_int32 *tabval,
l_int32 *tab38,
l_int32 *tab14,
l_int32 lastlineflag)
{
l_int32 j;
l_int32 oval, tab38val, tab14val;
l_uint8 rval, bval, dval;
if (lastlineflag == 0) {
for (j = 0; j < w - 1; j++) {
oval = GET_DATA_BYTE(bufs1, j);
SET_DATA_DIBIT(lined, j, tabval[oval]);
rval = GET_DATA_BYTE(bufs1, j + 1);
bval = GET_DATA_BYTE(bufs2, j);
dval = GET_DATA_BYTE(bufs2, j + 1);
tab38val = tab38[oval];
tab14val = tab14[oval];
if (tab38val < 0) {
rval = L_MAX(0, rval + tab38val);
bval = L_MAX(0, bval + tab38val);
dval = L_MAX(0, dval + tab14val);
}
else {
rval = L_MIN(255, rval + tab38val);
bval = L_MIN(255, bval + tab38val);
dval = L_MIN(255, dval + tab14val);
}
SET_DATA_BYTE(bufs1, j + 1, rval);
SET_DATA_BYTE(bufs2, j, bval);
SET_DATA_BYTE(bufs2, j + 1, dval);
}
/* do last column: j = w - 1 */
oval = GET_DATA_BYTE(bufs1, j);
SET_DATA_DIBIT(lined, j, tabval[oval]);
bval = GET_DATA_BYTE(bufs2, j);
tab38val = tab38[oval];
if (tab38val < 0)
bval = L_MAX(0, bval + tab38val);
else
bval = L_MIN(255, bval + tab38val);
SET_DATA_BYTE(bufs2, j, bval);
}
else { /* lastlineflag == 1 */
for (j = 0; j < w - 1; j++) {
oval = GET_DATA_BYTE(bufs1, j);
SET_DATA_DIBIT(lined, j, tabval[oval]);
rval = GET_DATA_BYTE(bufs1, j + 1);
tab38val = tab38[oval];
if (tab38val < 0)
rval = L_MAX(0, rval + tab38val);
else
rval = L_MIN(255, rval + tab38val);
SET_DATA_BYTE(bufs1, j + 1, rval);
}
/* do last pixel: (i, j) = (h - 1, w - 1) */
oval = GET_DATA_BYTE(bufs1, j);
SET_DATA_DIBIT(lined, j, tabval[oval]);
}
return;
}
/*!
* make8To2DitherTables()
*
* Input: &tabval (value assigned to output pixel; 0, 1, 2 or 3)
* &tab38 (amount propagated to pixels left and below)
* &tab14 (amount propagated to pixel to left and down)
* cliptoblack (values near 0 where the excess is not propagated)
* cliptowhite (values near 255 where the deficit is not propagated)
*
* Return: 0 if OK, 1 on error
*/
l_int32
make8To2DitherTables(l_int32 **ptabval,
l_int32 **ptab38,
l_int32 **ptab14,
l_int32 cliptoblack,
l_int32 cliptowhite)
{
l_int32 i;
l_int32 *tabval, *tab38, *tab14;
PROCNAME("make8To2DitherTables");
/* 3 lookup tables: 2-bit value, (3/8)excess, and (1/4)excess */
if ((tabval = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return ERROR_INT("tabval not made", procName, 1);
if ((tab38 = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return ERROR_INT("tab38 not made", procName, 1);
if ((tab14 = (l_int32 *)CALLOC(256, sizeof(l_int32))) == NULL)
return ERROR_INT("tab14 not made", procName, 1);
*ptabval = tabval;
*ptab38 = tab38;
*ptab14 = tab14;
for (i = 0; i < 256; i++) {
if (i <= cliptoblack) {
tabval[i] = 0;
tab38[i] = 0;
tab14[i] = 0;
}
else if (i < 43) {
tabval[i] = 0;
tab38[i] = (3 * i + 4) / 8;
tab14[i] = (i + 2) / 4;
}
else if (i < 85) {
tabval[i] = 1;
tab38[i] = (3 * (i - 85) - 4) / 8;
tab14[i] = ((i - 85) - 2) / 4;
}
else if (i < 128) {
tabval[i] = 1;
tab38[i] = (3 * (i - 85) + 4) / 8;
tab14[i] = ((i - 85) + 2) / 4;
}
else if (i < 170) {
tabval[i] = 2;
tab38[i] = (3 * (i - 170) - 4) / 8;
tab14[i] = ((i - 170) - 2) / 4;
}
else if (i < 213) {
tabval[i] = 2;
tab38[i] = (3 * (i - 170) + 4) / 8;
tab14[i] = ((i - 170) + 2) / 4;
}
else if (i < 255 - cliptowhite) {
tabval[i] = 3;
tab38[i] = (3 * (i - 255) - 4) / 8;
tab14[i] = ((i - 255) - 2) / 4;
}
else { /* i >= 255 - cliptowhite */
tabval[i] = 3;
tab38[i] = 0;
tab14[i] = 0;
}
}
#if 0
for (i = 0; i < 256; i++)
fprintf(stderr, "tabval[%d] = %d, tab38[%d] = %d, tab14[%d] = %d\n",
i, tabval[i], i, tab38[i], i, tab14[i]);
#endif
return 0;
}
/*------------------------------------------------------------------*
* Simple thresholding to 2 bpp *
*------------------------------------------------------------------*/
/*
* thresholdTo2bppLow()
*
* Low-level function for thresholding from 8 bpp (datas) to
* 2 bpp (datad), using thresholds implicitly defined through @tab,
* a 256-entry lookup table that gives a 2-bit output value
* for each possible input.
*
* For each line, unroll the loop so that for each 32 bit src word,
* representing four consecutive 8-bit pixels, we compose one byte
* of output consisiting of four 2-bit pixels.
*/
void
thresholdTo2bppLow(l_uint32 *datad,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_int32 *tab)
{
l_uint8 sval1, sval2, sval3, sval4, dval;
l_int32 i, j, k;
l_uint32 *lines, *lined;
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
for (j = 0; j < wpls; j++) {
k = 4 * j;
sval1 = GET_DATA_BYTE(lines, k);
sval2 = GET_DATA_BYTE(lines, k + 1);
sval3 = GET_DATA_BYTE(lines, k + 2);
sval4 = GET_DATA_BYTE(lines, k + 3);
dval = (tab[sval1] << 6) | (tab[sval2] << 4) |
(tab[sval3] << 2) | tab[sval4];
SET_DATA_BYTE(lined, j, dval);
}
}
return;
}
/*------------------------------------------------------------------*
* Simple thresholding to 4 bpp *
*------------------------------------------------------------------*/
/*
* thresholdTo4bppLow()
*
* Low-level function for thresholding from 8 bpp (datas) to
* 4 bpp (datad), using thresholds implicitly defined through @tab,
* a 256-entry lookup table that gives a 4-bit output value
* for each possible input.
*
* For each line, unroll the loop so that for each 32 bit src word,
* representing four consecutive 8-bit pixels, we compose two bytes
* of output consisiting of four 4-bit pixels.
*/
void
thresholdTo4bppLow(l_uint32 *datad,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_int32 *tab)
{
l_uint8 sval1, sval2, sval3, sval4;
l_uint16 dval;
l_int32 i, j, k;
l_uint32 *lines, *lined;
for (i = 0; i < h; i++) {
lines = datas + i * wpls;
lined = datad + i * wpld;
for (j = 0; j < wpls; j++) {
k = 4 * j;
sval1 = GET_DATA_BYTE(lines, k);
sval2 = GET_DATA_BYTE(lines, k + 1);
sval3 = GET_DATA_BYTE(lines, k + 2);
sval4 = GET_DATA_BYTE(lines, k + 3);
dval = (tab[sval1] << 12) | (tab[sval2] << 8) |
(tab[sval3] << 4) | tab[sval4];
SET_DATA_TWO_BYTES(lined, j, dval);
}
}
return;
}