#ifndef lint
static char sccsid[] = "@(#)mkcolor.c 9.2 88/01/19 Copyright 1985 Sun Micro";
#endif

/*
 * Copyright (c) 1985 by Sun Microsystems, Inc. 
 */

/*-
	Make a new colortbl.inc

	mkcolor.c, Tue May 13 16:28:08 1986

 */

unsigned char red[256],
            green[256],
            blue[256],
            grey[256];
unsigned char red_inverse[256],
            green_inverse[256],
            blue_inverse[256],
            grey_inverse[256];

int         ngrey,
            xgrey;


#define NR 5
#define NG 9
#define NB 5

int Ngrey;

static unsigned char dither_matrix[16][16];

static
make_dither_matrix(n)
    register    n;
{
    register    i,
                j;
    register    halfn;
    if (n <= 0)
	return;
    halfn = n >> 1;
    make_dither_matrix(halfn);
    for (i = 0; i < halfn; i++)
	for (j = 0; j < halfn; j++) {
	    register T;
	    register unsigned char *dmp = &dither_matrix[i][j];
            T = *dmp << 2;
            *dmp = T;
	    dither_matrix[i + halfn][j + halfn] = T + 1;
	    dither_matrix[i + halfn][j] = T + 2;
	    dither_matrix[i][j + halfn] = T + 3;
	}
}

grcomp(a, b)
    unsigned short *a,
               *b;
{
    return *a - *b;
}

main()
{
    register    r,
                g,
                b,
                i = 1;
    int         placed;
    int         interval;
    for (g = 0; g < NG; g++)
	for (b = 0; b < NB; b++)
	    for (r = 0; r < NR; r++) {
		red[i] = (r * 255) / (NR - 1);
		green[i] = (g * 255) / (NG - 1);
		blue[i] = (b * 255) / (NB - 1);
		if (red[i] == green[i] && green[i] == blue[i])
		    grey[ngrey++] = red[i];
		i++;
	    }
    i--;
    red[0] = 0XFF;
    green[0] = 0XFF;
    blue[0] = 0XFF;
    red[1] = 0;
    green[1] = 0;
    blue[1] = 0;
    xgrey = 256 - i;
    printf("/* DO NOT EDIT THIS FILE.  It was automatically generated by mkcolor\n");
    printf(" * %d red, %d green, %d blue\n", NR, NG, NB);
    printf(" * %d grey values in the basic table; %d added\n", ngrey, xgrey);
    b = 0;
    placed = 0;
    for (g = 0; g < ngrey; g++) {
	if ((r = grey[g] * (xgrey + ngrey) / 256 - placed + 1) > 1) {
	    register    k;
	    register    delta = grey[g] - b;
	    for (k = 1; k < r; k++) {
		red[i] = green[i] = blue[i] = b + k * delta / r;
		i++;
		placed++;
	    }
	}
	b = grey[g];
	placed++;
    }
#define swap1(m,a,b) (i = m[a], m[a] = m[b], m[b] = i)
#define swap3(a,b) (swap1(red,a,b),swap1(green,a,b),swap1(blue,a,b))
    swap3(254,255);
    swap3(255,256-xgrey);
    {
	unsigned short greytable[256];
	g = 0;
	for (i = 0; i < 256; i++)
	    if (red[i] == green[i] && green[i] == blue[i])
		greytable[g++] = (green[i] << 8) | i;
	qsort(greytable, g, sizeof greytable[0], grcomp);
	if (g != xgrey + ngrey)
	    printf("***MISSING GREYVALUES***\n");
	b = 0;
	for (i = 1; i < g; i++) {
	    register    mid = ((greytable[i - 1] >> 8) + (greytable[i] >> 8)) >> 1;
	    while (b < mid)
		grey_inverse[b++] = greytable[i - 1];
	}
	while (b < 256)
	    grey_inverse[b++] = greytable[g - 1];
    }

    printf(" */\n");
    dump(red, "red_map");
    dump(green, "green_map");
    dump(blue, "blue_map");
    compute_inverse(NR, 1, 0, red_inverse);
    dump(red_inverse, "red_inverse");
    compute_inverse(NG, NR*NB, 0, green_inverse);
    dump(green_inverse, "green_inverse");
    compute_inverse(NB, NR, 1, blue_inverse);
    dump(blue_inverse, "blue_inverse");
    dump(grey_inverse, "grey_inverse");
    make_dither_matrix(16);
    Ngrey = xgrey + ngrey;
    printf("static short  greyshade_pixels[%d][16] = {\n", Ngrey - 2);
    for (i = 0; ++i < Ngrey-1;) {
	register    x,
	            y,
	            val;
	for (y = 0; y < 16; y++) {
	    val = 0;
	    for (x = 0; x < 16; x++)
		if (dither_matrix[x][y] < 256 * i / Ngrey)
		    val |= 1 << x;
	    printf(" 0x%04x,", val);
	    if (y == 7)
		printf("\n ");
	}
	printf("\n");
    }
    printf("};\n");
    printf("static struct mpr_data greyshade_mpr[%d] = {\n", Ngrey-2);
    for (i = 0; i < Ngrey-2; i++)
	printf(" 2, greyshade_pixels[%d], 0, 0, 0, 0,\n", i);
    printf("};\nextern struct pixrectops mem_ops, tile_ops;\n");
    printf("static struct pixrect greyshade_pr[%d] = {\n", Ngrey-2);
    for (i = 0; i < Ngrey-2; i++)
	printf(" &mem_ops, 16, 16, 1, (caddr_t) &greyshade_mpr[%d], 0,\n", i);
    printf("};\n");
    printf("static struct pixrect greyshade_tile[%d] = {\n", Ngrey-2);
    for (i = 0; i < Ngrey-2; i++)
	printf(" &tile_ops, 9999, 9999, 1, (caddr_t) &greyshade_pr[%d], 0,\n", i);
    printf("};\n");
    printf("struct pixrect *grey_patterns[256] = {\n");
    for (i = 0; i<256; i++) {
	register t = red[i];
	if (green[i] > t) t = green[i];
	if (blue[i] > t) t = blue[i];
	t = t*Ngrey/256;
	if (t<=0 || t>=Ngrey-1)
	    printf(" 0,\n");
	else printf(" &greyshade_tile[%d],\n", Ngrey - 2 - t);
    }
    printf("};\n");
    printf("unsigned char grey_opcode[256] = {\n");
    for (i = 0; i<256; i++) {
	register t = red[i];
	if (green[i] > t) t = green[i];
	if (blue[i] > t) t = blue[i];
	t = t*Ngrey/256;
	if (t<=0) printf(" PIX_SET,");
	else if (t>=Ngrey-1) printf(" PIX_CLR,");
	else printf(" PIX_SRC,");
	if (((i+1)&7)==0) printf("\n");
    }
    printf("};\n");
    exit(0);
}

dump(arr, var)
    register unsigned char *arr;
    char       *var;
{
    register    i;
    printf("\nunsigned char %s[256] = {\n", var);
    for (i = 0;;) {
	printf("%3d,", *arr++);
	++i;
	if (i >= 256)
	    break;
	if ((i % 20) == 0)
	    printf("\n");
    }
    printf("\n};\n");
}


static
compute_inverse(N, stride, offset, inverse)
    register unsigned char *inverse;
    register short N, stride;
{
    register    short ipos;
    register halfslot = 256/N/2;
    for (ipos = 0; ipos < 256; ipos++) {
	inverse[ipos] = (ipos*N-halfslot)/256*stride + offset;
    }
}