gronod/argyllcms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity
Files
main
argyllcms/render/thscreen.c
T
gronod 45bdf51201 Initial commit of v3.5.0
2026-08-20 20:28:40 +01:00

715 lines
21 KiB
C
Raw Permalink Blame History

/*
* render2d
*
* Threshold or Error diffusion screen pixel processing object.
* (Simplified from DPS code)
*
* Author: Graeme W. Gill
* Date: 8/9/2005
* Version: 1.00
*
* Copyright 2005, 2012 Graeme W. Gill
* All rights reserved.
* This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
* see the License.txt file for licencing details.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <fcntl.h>
#include <string.h>
#include <math.h>
#include "aconfig.h"
#include "numlib.h"
//#include "icc.h"
#include "sort.h"
//#include "xcolorants.h"
#include "thscreen.h"
/* Configuration: */
#undef DEBUG
#undef CHECK_EXPECTED_ED_LEVELS /* Output expected quantized levels for checkking */
/* ----------------------------------------------------------- */
#ifdef DEBUG
# define DBG(text) printf text ; fflush(stdout);
#else
# define DBG(text)
#endif
/* ----------------------------------------------------------- */
/* Setup a set of screens */
/* Screen data is used that best matches the requested parameters. */
#include "screens.h" /* Pre-generated screen patterns */
/* Threshold screen lines of multiplane pixels */
void screen_thscreens(
thscreens *t, /* Screening object pointer */
int width, int height, /* Width and height to screen in pixels */
int xoff, int yoff, /* Offset into screening pattern */
unsigned char *out, /* Output pixel buffer */
unsigned long opitch, /* Increment between output lines in components */
unsigned char *in, /* Input pixel buffer */
unsigned long ipitch /* Increment between input lines in components */
) {
int i;
for (i = 0; i < t->np; i++)
t->sc[i]->screen(t->sc[i], width, height, xoff, yoff,
out + i, t->np, opitch,
in + 2 * i, t->np, ipitch);
}
/* Error diffusion screen lines of multiplane pixels */
void screen_edscreens(
thscreens *t, /* Screening object pointer */
int width, int height, /* Width and height to screen in pixels */
int xoff, int yoff, /* Offset into screening pattern, [xoff + width < mxwidth] */
unsigned char *out, /* Output pixel buffer */
unsigned long opitch, /* Increment between output lines in components */
unsigned char *_in, /* Input pixel buffer */
unsigned long ipitch /* Increment between input lines in components */
) {
unsigned short *in = (unsigned short *)_in; /* Pointer to input pixel sized values */
unsigned short *ein = in + height * ipitch; /* Vertical end pixel marker */
unsigned short *ein1; /* Horizontal end pixel markers */
int xo, yo; /* Threshold screen offset */
int x, j;
/* Limit width to mxwidth */
if ((xoff + width) > t->mxwidth) {
width = t->mxwidth - xoff;
if (width < 0)
return;
}
/* If not sequential, clear error buffer */
if (yoff != (t->lastyoff+1)) {
for (x = -1; x <= t->mxwidth; x++) {
for (j = 0; j < t->np; j++)
t->ebuf[j][x] = 0.0;
}
}
/* Clear "next to right" error */
for (j = 0; j < t->np; j++) {
t->ebuf[j][-2] = 0.0;
}
t->lastyoff = yoff;
/* For each line: */
for (; in < ein; in += ipitch, ein1 += ipitch, out += opitch, yoff++) {
unsigned short *ip; /* Horizontal input pointer */
unsigned char *op; /* Horizontal output pointer */
int xinc, pinc;
/* Do in serpentine order */
if (yoff & 1) {
xinc = -1;
x = xoff + width-1; /* x is index into error buffer */
pinc = -t->np;
ein1 = in + pinc;
ip = in + t->np * (width-1);
op = out + t->np * (width-1);
} else {
xinc = 1;
x = xoff;
pinc = t->np;
ein1 = in + t->np * width;
ip = in;
op = out;
}
/* For each pixel */
for (; ip != ein1; ip += pinc, op += pinc, x += xinc) {
double ov[THMXCH2D], tv[THMXCH2D], ev[THMXCH2D];
/* Limit error propogation if asked */
if (t->mxerr != 0.0) {
for (j = 0; j < t->np; j++) {
if (t->ebuf[j][x] < -t->mxerr)
t->ebuf[j][x] = -t->mxerr;
else if (t->ebuf[j][x] > t->mxerr)
t->ebuf[j][x] = t->mxerr;
}
}
/* For each plane */
for (j = 0; j < t->np; j++) {
tv[j] = t->luts[j][ip[j]] / 65535.0; /* 0.0 - 1.0 value */
/* Value + accumulated error */
ov[j] = tv[j] = tv[j] + t->ebuf[j][x];
/* Limit */
if (ov[j] > 1.0)
ov[j] = 1.0;
else if (ov[j] < 0.0)
ov[j] = 0.0;
/* Output encode */
op[j] = t->oevalues[(int)(ov[j] * (t->oelev-1.0) + 0.5)];
}
#ifdef CHECK_EXPECTED_ED_LEVELS
#pragma message("######### render/thscreen.c CHECK_EXPECTED_ED_LEVELS defined ! ##")
// Put expected values in output to check levels
t->quant(t->qcntx, ev, ov);
for (j = 0; j < t->np; j++)
op[j] = t->oevalues[(int)(ev[j] * (t->oelev-1.0) + 0.5)];
#endif
/* Quantize to values that it actually will be */
if (t->quant != NULL)
t->quant(t->qcntx, ov, ov);
else {
for (j = 0; j < t->np; j++)
ov[j] = floor(ov[j] * (t->oelev-1) + 0.5)/(t->oelev-1.0);
}
/* Compute the error to the target */
for (j = 0; j < t->np; j++) {
/* Error to target */
ev[j] = tv[j] - ov[j];
}
/* Distribute the error */
for (j = 0; j < t->np; j++) {
#ifdef NEVER
/* Classic error diffusion */
t->ebuf[j][x-xinc] += 0.1875 * ev[j]; /* Lower left */
t->ebuf[j][x] = t->ebuf[j][-2] + 0.3125 * ev[j]; /* Lower */
t->ebuf[j][-2] = 0.0625 * ev[j]; /* Lower right */
t->ebuf[j][x+xinc] += 0.4375 * ev[j]; /* Right */
#else
/* Using random placement error distribution */
double rav;
int ii;
t->so->next(t->so, &rav); /* For some order */
rav *= 4.0;
rav += d_rand(0.0, 2.5); /* For some randomness */
ii = (int)(rav);
if (ii > 3)
ii -= 4;
t->ebuf[j][x] = t->ebuf[j][-2];
t->ebuf[j][-2] = 0.0;
switch (ii) {
case 0:
t->ebuf[j][x-xinc] += ev[j]; /* Lower left */
break;
case 1:
t->ebuf[j][x] += ev[j]; /* Lower */
break;
case 2:
t->ebuf[j][-2] += ev[j]; /* Lower right */
break;
case 3:
t->ebuf[j][x+xinc] += ev[j]; /* Right */
break;
}
#endif
}
}
}
}
/* Delete a thscreens */
void del_thscreens(thscreens *t) {
int i;
if (t->sc != NULL) {
for (i = 0; i < t->np; i++) {
if (t->sc[i] != NULL)
t->sc[i]->del(t->sc[i]);
}
free(t->sc);
}
if (t->ebuf != NULL) {
free_fmatrix(t->ebuf, 0, t->np-1, -2, t->mxwidth);
}
if (t->luts != NULL) {
free_imatrix(t->luts, 0, t->np-1, 0, 65535);
}
if (t->so != NULL)
t->so->del(t->so);
free(t);
}
/* Create a new thscreens object matching the parameters */
thscreens *new_thscreens(
int exact, /* Return only exact matches */
int nplanes, /* Number of planes to screen */
double asp, /* Target aspect ratio (== dpiX/dpiY) */
int size, /* Target screen size */
sc_iencoding ie, /* Input encoding - must be scie_16 */
int oebpc, /* Output encoding bits per component - must be 8 */
int oelev, /* Output encoding levels. Must be <= 2 ^ oebpc */
int *oevalues, /* Optional output encoding values for each level */
/* Must be oelev entries. Default is 0 .. oelev-1 */
sc_oorder oo, /* Output bit ordering */
double overlap, /* Overlap between levels, 0 - 1.0 */
int mxwidth, /* max width in pixels of raster to be screened */
void **cntx, /* List of contexts for lookup table callback */
double (**lutfunc)(void *cntx, double in), /* List of callback functions, NULL if none */
int edif, /* nz if using error diffusion */
void (*quant)(void *qcntx, double *out, double *in), /* optional quantization func. for edif */
void *qcntx,
double mxerr /* If error diffusion anf != 0, max error to propogate */
) {
thscreens *t;
int i, bi = -1;
double bamatch; /* Best aspect match */
int bsize = 100000; /* Best size match */
int swap = 0; /* width and height will need swapping */
DBG(("thscreens: new called with:\n"));
DBG((" nplanes = 0x%x\n",nplanes));
DBG((" asp = %f\n",asp));
DBG((" ie = %d\n",ie));
DBG((" oebpc = %d\n",oebpc));
DBG((" oelev = %d\n",oelev));
DBG((" oo = %d\n",oo));
DBG((" overlap = %f\n",overlap));
if (asp < 1.0) { /* All screens[] have asp >= 1.0 */
asp = 1.0/asp;
swap = 1;
DBG(("thscreens: aspect swap needed\n"));
}
if ((t = (thscreens *)calloc(1, sizeof(thscreens))) == NULL) {
DBG(("thscreens: malloc of thscreens failed\n"));
return NULL;
}
t->np = nplanes; /* Number of planes */
t->edif = edif; /* Error diffusion */
t->quant = quant; /* Optional quantization function */
t->qcntx = qcntx;
t->mxwidth = mxwidth;
t->mxerr = mxerr;
t->lastyoff = -1;
/* Allocate and initialise a next line error buffer. */
/* we allow 2 extra locations for pixels to the left and right of the current one: */
/* [-1] for the one to the below left when we are at x = 0, */
/* [-2] for the one below right, before we use [x] */
if (t->edif)
t->ebuf = fmatrixz(0, t->np-1, -2, t->mxwidth);
t->oebpc = oebpc;
t->oelev = oelev;
if (oevalues != NULL) {
for (i = 0; i < t->oelev; i++) {
if (oevalues[i] >= (1 << t->oebpc)) {
DBG(("new_thscreens() oevalues[%d] value %d can't fit in %d bits\n",i,oevalues[i],t->oebpc));
free(t);
return NULL;
}
t->oevalues[i] = oevalues[i];
}
} else {
for (i = 0; i < t->oelev; i++)
t->oevalues[i] = i;
}
DBG(("thscreens no planes = %d\n",t->np));
t->del = del_thscreens;
DBG(("thscreens: searching amongst %d screens, exact = %d\n",NO_SCREENS,exact));
DBG(("thscreens: looking for non-exact match\n"));
/* Synthesise a set of screens from what's there */
/* (Don't bother with matching the colorspace) */
for (i = 0;i < NO_SCREENS; i++) {
double thamatch; /* This aspect match */
int thsize; /* This size match */
thamatch = asp/screens[i].asp;
if (thamatch < 1.0)
thamatch = 1.0/thamatch;
if (bi < 0 || (thamatch < bamatch)) { /* No best or new best */
bamatch = thamatch;
bi = i;
DBG(("thscreens: new best with aspmatch %f\n",bamatch));
continue; /* On to next */
}
if (thamatch > bamatch) /* Worse aspect match */
continue;
/* Same on aspect ratio. Check size */
thsize = size - screens[i].size;
if (thsize < 0)
thsize = -thsize;
if (thsize < bsize) { /* New better size match */
bsize = thsize;
bi = i;
DBG(("thscreens: new best with size %d\n",bsize));
}
}
if (bi < 0) /* Strange */
return NULL;
if (t->edif) {
int j;
int npix;
t->screen = screen_edscreens;
t->luts = imatrix(0, t->np-1, 0, 65535);
/* Create a suitable LUT from the given function */
/* Input is either 8 or 16 bits, output is always 16 bits */
for (j = 0; j < t->np; j++) {
for (i = 0; i < 65536; i++) {
if (lutfunc != NULL && lutfunc[j] != NULL) {
double v = i/65535.0;
v = lutfunc[j](cntx[j], v);
t->luts[j][i] = (int)(v * 65535.0 + 0.5);
} else
t->luts[j][i] = i;
}
}
if ((t->so = new_sobol(1)) == NULL) {
DBG(("thscreens: new_sobol() failed\n"));
return NULL;
}
} else {
t->screen = screen_thscreens;
if ((t->sc = malloc(sizeof(thscreen *) * t->np)) == NULL) {
free(t);
DBG(("thscreens: malloc of thscreens->sc[] failed\n"));
return NULL;
}
/* Create each screening object from one defined screen. */
/* Use the 0'th plane screen */
/* Stagger the screens with a round of 9 offset */
for (i = 0; i < t->np; i++) {
int xoff = ((i % 3) * screens[bi].width)/3;
int yoff = (((i/3) % 3) * screens[bi].height)/3;
void *cx = NULL;
double (*lf)(void *cntx, double in) = 0;
if (cntx != NULL)
cx = cntx[i];
if (lutfunc != NULL)
lf = lutfunc[i];
DBG(("thscreens: creating plane %d/%d thscreen, offset %d %d\n",i,t->np,xoff,yoff));
if ((t->sc[i] = new_thscreen(screens[bi].width, screens[bi].height, xoff, yoff,
screens[bi].asp, swap, screens[bi].list[0],
ie, oebpc, oelev, oevalues, oo, overlap,
cx, lf)) == NULL) {
for (--i; i >= 0; i--)
t->sc[i]->del(t->sc[i]);
free(t->sc);
free(t);
DBG(("thscreens: new_thscreen() failed\n"));
return NULL;
}
}
}
DBG(("thscreens: returning nonexact match\n"));
return t;
}
/* ----------------------------------------------------------- */
/* The kernel stocastic screening routine */
void thscreen16_8(
struct _thscreen *t, /* Screening object pointer */
int width, int height, /* Width and height to screen in pixels */
int xoff, int yoff, /* Offset into screening pattern (must be +ve) */
unsigned char *out, /* Output pixel buffer */
unsigned long opinc, /* Increment between output pixels in components */
unsigned long opitch, /* Increment between output lines in components */
unsigned char *_in, /* Input pixel buffer */
unsigned long ipinc, /* Increment between input pixels in components */
unsigned long ipitch /* Increment between input lines in components */
) {
unsigned short *in = (unsigned short *)_in; /* Pointer to input pixel sized values */
int *lut = t->lut; /* Copy of 8 or 16 -> 16 bit lookup table */
unsigned short *ein = in + height * ipitch; /* Vertical end pixel marker */
unsigned short *ein1; /* Horizontal end pixel markers */
unsigned char **oth, **eth; /* Current lines start, origin and end in screening table. */
int thtsize; /* Overall size of threshold table */
unsigned char **eeth; /* Very end of threshold table */
{
unsigned char **sth; /* Start point of line intable */
sth = t->thp + (yoff % t->sheight) * t->twidth;
oth = sth + (xoff % t->swidth); /* Orgin of pattern to start from */
eth = sth + t->swidth; /* Ending point to wrap back */
thtsize = t->twidth * t->theight;
eeth = t->thp + thtsize; /* very end of table */
}
ein1 = in + ipinc * width;
/* For each line: */
for (; in < ein; in += ipitch, ein1 += ipitch, out += opitch) {
unsigned char **th = oth; /* Threshold table origin */
unsigned short *ip = in; /* Horizontal input pointer */
unsigned char *op = out; /* Horizontal output pointer */
/* Do pixels one output byte at a time */
for (; ip < ein1; ip += ipinc, op += opinc) {
int tt = lut[*ip];
*op = (unsigned char)th[0][tt];
if (++th >= eth)
th -= t->swidth;
}
/* Advance screen table pointers with vertical wrap */
oth += t->twidth;
eth += t->twidth;
if (eth > eeth) {
oth -= thtsize;
eth -= thtsize;
}
}
}
/* ----------------------------------------------------------- */
/* We're done with the screening object */
static void th_del(
thscreen *t
) {
if (t->lut != NULL)
free(t->lut);
if (t->thp != NULL)
free(t->thp);
free(t);
}
/* Create a new thscreen object */
/* Return NULL on error */
thscreen *new_thscreen(
int width, /* width in pixels of screen */
int height, /* Height in pixels of screen */
int xoff, int yoff, /* Pattern offsets into width & height */
double asp, /* Aspect ratio of screen (== dpiX/dpiY) */
int swap, /* Swap X & Y to invert aspect ratio & swap width/height */
ccoord *thli, /* Pointer to list of threshold coordinates */
sc_iencoding ie, /* Input encoding - must be scie_16 */
int oebpc, /* Output encoding bits per component - must be 8 */
int oelev, /* Output encoding levels. Must be <= 2 ^ oebpc */
int *oevalues, /* Optional output encoding values for each level */
/* Must be oelev entries. Default is 0 .. oelev-1 */
sc_oorder oo, /* Output bit ordering */
double olap, /* Overlap between levels, 0 - 1.0 */
void *cntx, /* Context for LUT table callback */
double (*lutfunc)(void *cntx, double in) /* Callback function, NULL if none */
) {
thscreen *t; /* Object being created */
int npix; /* Total pixels in screen */
double mrang; /* threshold modulation range */
double **fthr; /* Floating point threshold array */
int i, j;
DBG(("new_thscreen() called, oebpc = %d\n",oebpc));
DBG(("new_thscreen() called, oelev = %d\n",oelev));
/* Sanity check overlap */
if (olap < 0.0)
olap = 0.0;
else if (olap > 1.0)
olap = 1.0;
/* Sanity check parameters */
if (ie != scie_16) {
DBG(("new_thscreen() ie %d != scie_16\n",ie));
return NULL;
}
if (oebpc != 8) {
DBG(("new_thscreen() oebpc %d != 8\n",oebpc));
return NULL;
}
if (oelev < 2 || oelev > (1 << oebpc)) {
DBG(("new_thscreen() oelev %d > 2^%d = %d\n",oelev,1 << oebpc,oebpc));
return NULL;
}
if ((t = (thscreen *)calloc(1, sizeof(thscreen))) == NULL) {
DBG(("new_thscreen() calloc failed\n"));
return NULL;
}
/* Instantiation parameters */
t->ie = ie;
t->oebpc = oebpc;
t->oelev = oelev;
if (oevalues != NULL) {
for (i = 0; i < t->oelev; i++) {
if (oevalues[i] >= (1 << t->oebpc)) {
DBG(("new_thscreen() oevalues[%d] value %d can't fit in %d bits\n",i,oevalues[i],t->oebpc));
free(t);
return NULL;
}
t->oevalues[i] = oevalues[i];
}
} else {
for (i = 0; i < t->oelev; i++)
t->oevalues[i] = i;
}
t->oo = oo;
t->overlap = olap;
/* Create a suitable LUT from the given function */
/* Input is either 8 or 16 bits, output is always 16 bits */
DBG(("new_thscreen() about to create LUT\n"));
if ((t->lut = (int *)malloc(sizeof(int) * 65536)) == NULL) {
free(t);
DBG(("new_thscreen() malloc of 16 bit LUT failed\n"));
return NULL;
}
for (i = 0; i < 65536; i++) {
if (lutfunc != NULL) {
double v = i/65535.0;
v = lutfunc(cntx, v);
t->lut[i] = (int)(v * 65535.0 + 0.5);
} else
t->lut[i] = i;
}
/* Screen definition parameters */
if (swap) {
t->asp = 1.0/asp;
t->swidth = height;
t->sheight = width;
} else {
t->asp = asp;
t->swidth = width;
t->sheight = height;
}
DBG(("new_thscreen() target width %d, height %d, asp %f\n",t->swidth,t->sheight,t->asp));
DBG(("new_thscreen() given width %d, height %d, asp %f\n",width,height,asp));
npix = t->swidth * t->sheight; /* Total pixels */
/* Allow for read of a words worth of pixels from within screen: */
DBG(("new_thscreen() tot pix %d, lev %d, bpp %d\n",npix,t->oelev,t->oebpc));
t->twidth = t->swidth + (8/t->oebpc) -1;
t->theight = t->sheight;
DBG(("new_thscreen() th table size = %d x %d\n",t->twidth,t->theight));
DBG(("new_thscreen() about to turn screen list into float threshold matrix\n"));
/* Convert the list of screen cells into a floating point threshold array */
fthr = dmatrix(0, t->sheight-1, 0, t->swidth-1); /* Temporary matrix */
if (swap) {
double tt = xoff; /* Swap offsets to align with orientation */
xoff = yoff;
yoff = tt;
for (i = 0; i < npix; i++)
fthr[thli[i].x][thli[i].y] = (double)(i/(npix - 1.0));
} else {
for (i = 0; i < npix; i++)
fthr[thli[i].y][thli[i].x] = (double)(i/(npix - 1.0));
}
/* The range that the screen has to modulate */
/* over to cross all the thresholds evenly. */
mrang = 65535.0/(t->oelev - 1.0);
DBG(("new_thscreen() raw modulation rande = %f\n",mrang));
/* Modify the modulation range to accommodate any level overlap */
if (olap > 0.0 && t->oelev > 2) {
mrang = ((t->oelev - 2.0) * olap * mrang + 65535.0)/(t->oelev - 1.0);
DBG(("new_thscreen() modulation adjusted for overlap = %f\n",mrang));
}
/* Init the threshold table. It holds the quantized, encoded output */
/* values, allowing an input value offset by the screen to be */
/* thresholded directly into the output value. We allow a guard band at */
/* each end for the effects of the screen modulating the input value. */
DBG(("new_thscreen() about to init threshold table\n"));
t->tht = &t->_tht[32768]; /* base allows for -ve & +ve range */
for (i = -32768; i < (2 * 65536) + 32768; i++) {
if (i < mrang) { /* Lower guard band */
t->tht[i] = t->oevalues[0];
} else if (i >= 65535) { /* Upper guard band */
t->tht[i] = t->oevalues[t->oelev-1];
} else { /* Middle range */
t->tht[i] = t->oevalues[1 + (int)((t->oelev - 2.0) * (i - mrang)/(65535.0 - mrang))];
}
}
/* Allocate the 2D table of pointers into the */
/* threshold table that encodes the screen offset. */
if ((t->thp = (unsigned char **)malloc(sizeof(unsigned char *)
* t->twidth * t->theight)) == NULL) {
free_dmatrix(fthr, 0, t->sheight-1, 0, t->swidth-1);
free(t->lut);
free(t);
DBG(("new_thscreen() malloc of threshold pointer matrix failed\n"));
return NULL;
}
/* Setup the threshold pointer array to point into the apropriate */
/* point into the threshold array itself. This implicitly adds */
/* the screen pattern offset value to the input before thresholding it. */
/* The input screen offsets are applied at this point too. */
DBG(("new_thscreen() about to init threshold pointer table\n"));
for (i = 0; i < t->twidth; i++) {
for (j = 0; j < t->theight; j++) {
double sov = fthr[(j+yoff) % t->sheight][(i+xoff) % t->swidth];
int tho = (int)((mrang - 1.0) * (1.0 - sov) + 0.5);
t->thp[j * t->twidth + i] = &t->tht[tho];
}
}
free_dmatrix(fthr, 0, t->sheight-1, 0, t->swidth-1);
DBG(("new_thscreen() about to setup method pointers\n"));
/* Methods */
t->screen = thscreen16_8;
t->del = th_del;
DBG(("new_thscreen() done\n"));
return t;
}
Reference in New Issue View Git Blame Copy Permalink