#include <stdio.h>
#include <math.h>
#include "rle.h"

Include dependency graph for to8.c:

Macros
#define	DMAP(v, x, y) (modN[v]>dm16[x][y] ? divN[v] + 1 : divN[v])

Functions
void	init_color ()

void	map_scanline ()

void	main (int argc, char **argv)

void	map_scanline (rgb, int n, int y,*line)

Variables
static char	rcs_ident [] = "$Header: /tmp_mnt/n/itn/hendrix/u/spencer/RCS/to8.c,v 3.0.1.4 1992/04/30 14:14:43 spencer Exp spencer $"

short	map [3][256]

int	colmap [216][3]

rle_pixel **	in_cmap

int	dm16 [16][16]

int	modN [256]

int	divN [256]

double	disp_gam = 2.5

double	img_gam = 1.0

Macro Definition Documentation

#define DMAP	(	v,
		x,
		y
	)	(modN[v]>dm16[x][y] ? divN[v] + 1 : divN[v])

Definition at line 236 of file to8.c.

Function Documentation

void init_color ( )

Definition at line 218 of file to8.c.

References colmap, disp_gam, dithermap(), divN, dm16, map, and modN.

 {
     int     i;
 
     dithermap( 6, disp_gam, colmap, divN, modN, dm16 );
 
     for (i = 0; i < 216; i++)
     {
     map[0][i] = colmap[i][0] << 8;
     map[1][i] = colmap[i][1] << 8;
     map[2][i] = colmap[i][2] << 8;
     }
 
 }

Here is the call graph for this function:

void main	(	int	argc,
		char **	argv
	)

Definition at line 77 of file to8.c.

 {
     char * infname = NULL, * outfname = NULL;
     char comment[80];       /* for gamma comment */
     FILE * outfile = stdout;
     int oflag = 0, y, nrow, iflag = 0, gflag = 0;
     rle_hdr     in_hdr, out_hdr;
     unsigned char ** scan, *outscan[2];
     unsigned char * buffer;
     int rle_cnt, rle_err;
 
     in_hdr = *rle_hdr_init( NULL );
     out_hdr = *rle_hdr_init( NULL );
 
     if ( scanargs( argc, argv,
            "% Ii%-gamma!F g%-gamma!F o%-outfile!s infile%s",
            &iflag, &img_gam, &gflag, &disp_gam,
            &oflag, &outfname, &infname ) == 0 )
     exit( 1 );
     in_hdr.rle_file = rle_open_f(cmd_name( argv ), infname, "r");
     rle_names( &in_hdr, cmd_name( argv ), infname, 0 );
     rle_names( &out_hdr, in_hdr.cmd, outfname, 0 );
 
     for ( rle_cnt = 0;
       (rle_err = rle_get_setup( &in_hdr )) == RLE_SUCCESS;
       rle_cnt++ )
     {
 
     if ( in_hdr.ncolors == 1 )
     {
         fprintf( stderr, "%s is already black & white\n",
              infname ? infname : "stdin" );
         exit( 1 );
     }
     if ( in_hdr.ncolors < 3 )
     {
         fprintf( stderr, "%s is not RGB",
              infname ? infname : "stdin" );
         exit( 1 );
     }
 
     /* If no image gamma on command line, check comments in file */
     if ( ! iflag )
     {
         char * v;
         if ( (v = rle_getcom( "image_gamma", &in_hdr )) != NULL )
         {
         img_gam = atof( v );
         /* Protect against bogus information */
         if ( img_gam == 0.0 )
             img_gam = 1.0;
         else
             img_gam = 1.0 / img_gam;
         }
         else if ( (v = rle_getcom( "display_gamma", &in_hdr )) != NULL )
         {
         img_gam = atof( v );
         /* Protect */
         if ( img_gam == 0.0 )
             img_gam = 1.0;
         }
     }
 
     (void)rle_hdr_cp( &in_hdr, &out_hdr );
     if ( rle_cnt == 0 )
         outfile = rle_open_f(cmd_name( argv ), outfname, "w");
     in_hdr.xmax -= in_hdr.xmin;
     in_hdr.xmin = 0;
     nrow = in_hdr.xmax + 1;
     buffer = (unsigned char *)malloc( nrow );
     RLE_CHECK_ALLOC( cmd_name( argv ), buffer, 0 );
     if ( rle_row_alloc( &in_hdr, &scan ) < 0 )
         RLE_CHECK_ALLOC( cmd_name( argv ), 0, 0 );
 
     if ( in_hdr.alpha )
     {
         outscan[0] = scan[-1];
     }
     outscan[1] = buffer;
 
     /* Use input color map, too */
     in_cmap = buildmap( &in_hdr, 3, img_gam, 1.0 );
 
     init_color();
     out_hdr.ncolors = 1;
     out_hdr.ncmap = 3;
     out_hdr.cmaplen = 8;    /* 256 entries */
     out_hdr.cmap = (rle_map *)map;
     /* Delete color map length comment, if present. */
     rle_delcom( "color_map_length", &out_hdr );
 
     /* Record gamma color map was computed for */
     sprintf( comment, "display_gamma=%g", disp_gam );
     rle_putcom( comment, &out_hdr );
 
     /*
      * Give it a background color of black, since the real background
      * will be dithered anyway.
      */
     if ( in_hdr.background != 0 )
     {
         out_hdr.bg_color = (int *)malloc( sizeof( int ) );
         RLE_CHECK_ALLOC( cmd_name( argv ), out_hdr.bg_color, 0 );
         out_hdr.bg_color[0] = 0;
     }
 
     out_hdr.rle_file = outfile;
 
     rle_addhist( argv, &in_hdr, &out_hdr );
 
     rle_put_setup( &out_hdr );
 
     while ( (y = rle_getrow( &in_hdr, scan )) <=
         in_hdr.ymax )
     {
         map_scanline( scan, nrow, y, buffer );
         rle_putrow( &outscan[1], nrow, &out_hdr );
     }
 
     rle_puteof( &out_hdr );
 
     rle_row_free( &in_hdr, scan );
     }
 
     /* Check for an error.  EOF or EMPTY is ok if at least one image
      * has been read.  Otherwise, print an error message.
      */
     if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
     rle_get_error( rle_err, cmd_name( argv ), infname );
 
     exit( 0 );
 }

void map_scanline ( )

void map_scanline	(	rgb	,
		int	n,
		int	y,
		*	line
	)

Definition at line 239 of file to8.c.

 {
     register unsigned char *r, *g, *b;
     register int i, col, row;
     for ( row = y % 16, col = 0, i = 0, r = rgb[0], g = rgb[1], b = rgb[2];
           i < n; i++, r++, g++, b++, col = ((col + 1) & 15) )
         line[i] = DMAP(in_cmap[0][*r], col, row) +
               DMAP(in_cmap[1][*g], col, row) * 6 +
               DMAP(in_cmap[2][*b], col, row) * 36;
 }