get_orion.c File Reference

#include <stdio.h>
#include <math.h>
#include <graphics/grafix.h>
#include <graphics/window.h>
#include <graphics/control.h>
#include <graphics/events.h>
#include <sys/ioctl.h>
#include <machine/graphics.h>
#include "rle.h"

Include dependency graph for get_orion.c:

Go to the source code of this file.

Macros
#define	RASTERSIZE_LIM   1280
#define	MONOCHROME_MODE   1
#define	EIGHT_BIT_COLOUR_MODE   2
#define	MONOCHROME_ENTRIES   128
#define	DMAP(v, x, y)    (errN[v]>dm16[x][y] ? divN[v]+1 : divN[v])
#define	WriteCLT(cltp)   (ioctl (_gdev, GTIOCSCLT, &(cltp)))
#define	ReadCLT(cltp)    (ioctl (_gdev, GTIOCGCLT, &(cltp)))

Typedefs
typedef int	boolean

Functions
	main (int argc, argv)
	init_gamma_map ()
	init_8_bit_colour_map ()
	init_monochrome_colour_map ()
	init_24_bit_colour_map ()
	put_line_8 (int yscan)
	put_line_mono (int yscan)
	write_colour_map ()
	write_scanline (int yscan)
	translate_bits (BitMapPtr db, Rect dr)
	EventLoop ()
	MyClose ()
	MyActivate ()

Variables
rle_hdr *	hdr
unsigned char	scanline [4][1280]
unsigned char *	rows [4]
unsigned char	dest_pixels [1280]
BitMap	scanbitmap
Rect	trandr
int	dm16 [16][16]
int	errN [256]
int	divN [256]
int	gammamap [256]
float	gam = 2.0
boolean	linear_flag = FALSE
boolean	gamma_flag = FALSE
boolean	all_colours_flag = FALSE
int	put_mode = 2
int	n_colmap_colours
int	colmap [256][3]
WindowPtr	rle_window
EventRecord	myEvent
WindowPtr	whichWindow
Point	myPt
int	thePart
boolean	isActive = FALSE
int	window_size_x
int	window_size_y
boolean	debug_flag = FALSE
boolean	reverse_flag = FALSE
boolean	onec_threem_mode = FALSE

Macro Definition Documentation

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

Definition at line 310 of file get_orion.c.

#define EIGHT_BIT_COLOUR_MODE   2

Definition at line 26 of file get_orion.c.

#define MONOCHROME_ENTRIES   128

Definition at line 27 of file get_orion.c.

#define MONOCHROME_MODE   1

Definition at line 25 of file get_orion.c.

#define RASTERSIZE_LIM   1280

Definition at line 24 of file get_orion.c.

#define ReadCLT

(

cltp

)

(ioctl (_gdev, GTIOCGCLT, &(cltp)))

Definition at line 434 of file get_orion.c.

#define WriteCLT

(

cltp

)

(ioctl (_gdev, GTIOCSCLT, &(cltp)))

Definition at line 433 of file get_orion.c.

Typedef Documentation

typedef int boolean

Definition at line 31 of file get_orion.c.

Function Documentation

EventLoop

(

)

Definition at line 566 of file get_orion.c.

{
    while (TRUE)
    {
    GetNextEvent (everyEvent, &myEvent);
    switch (myEvent.what)
    {
    case mouseDown:
        whichWindow = (WindowPtr) myEvent.refCon;
        switch (FindWindow (myEvent.where, whichWindow))
        {
        case inGoAway: 
        if (TrackGoAway (whichWindow, myEvent.where))
        {
            MyClose ();
        }
        break;

        case inDrag: 
        DragWindow (whichWindow, myEvent.where, stdBoundsRect);
        break;

        case inContent: 
        if (whichWindow != FrontWindow ())
        {
            BringToFront (whichWindow);
        }
        else
        {
            myPt = myEvent.where;
            GlobalToLocal (&myPt);
        }
        break;
        }
    break;  /* End of mouseDown */

    case activate:
        MyActivate ();
    break;
    }   
    } /* while (TRUE) */
}

init_24_bit_colour_map

(

)

Definition at line 289 of file get_orion.c.

References rle_hdr::cmap, rle_hdr::cmaplen, colmap, hdr, and n_colmap_colours.

{
    int i, g_offset, b_offset;

    /* set up the colour map entries, will use the number supplied in the
       header */
    n_colmap_colours = 1 << hdr.cmaplen;
    g_offset = n_colmap_colours;
    b_offset = 2 * g_offset;

    /* set the device colour map to the one in the header  */
    for (i = 0; i < n_colmap_colours; i++) {
    colmap[i][0] = hdr.cmap[i];
    colmap[i][1] = hdr.cmap[i + g_offset];
    colmap[i][2] = hdr.cmap[i + b_offset];
    }
}

init_8_bit_colour_map

(

)

Definition at line 244 of file get_orion.c.

References colmap, dithermap(), divN, dm16, errN, and n_colmap_colours.

{
    double gamma;

    /* Set up the colour map entries. We will use 216 colours. */
    n_colmap_colours = 216;

    /* calculate tables but don't gamma correct the colour map */
    gamma = 1.0;
    dithermap(6, gamma, colmap, divN, errN, dm16);
}

Here is the call graph for this function:

init_gamma_map

(

)

Definition at line 228 of file get_orion.c.

References gam, and gammamap.

{
    int i;

    for (i = 0; i < 256; i++) {
        gammamap[i] = (int) (0.5 + 255 * pow(i / 255.0, 1.0/gam));
    }
}

init_monochrome_colour_map

(

)

Definition at line 264 of file get_orion.c.

References bwdithermap(), colmap, divN, dm16, errN, and n_colmap_colours.

{
    int i, bwmap[256];
    double gamma;

    /* Set up the colour map entries into a single greyscale ramp */
    n_colmap_colours = MONOCHROME_ENTRIES;

    /* calculate tables but don't gamma correct the colour map */
    gamma = 1.0;
    bwdithermap(n_colmap_colours, gamma, bwmap, divN, errN, dm16);
    for (i = 0; i < n_colmap_colours; i++)
    colmap[i][0] = colmap[i][1] = colmap[i][2] = bwmap[i];

}

Here is the call graph for this function:

main	(	int	argc,
		argv
	)

Definition at line 114 of file get_orion.c.

{
    int i, temp;
    int bw_flag = 0;
    char *infname = NULL, *window_name;
    FILE *fopen();
    Rect r;

    hdr = *rle_hdr_init( (rle_hdr *)NULL );

    /* Get command line arguments */
    if (scanargs(argc, argv, "getOrion D%- w%- f%- g%-gamma!f l%- r%- infile
%s",
     &debug_flag, &bw_flag, &all_colours_flag, 
     &gamma_flag, &gam, &linear_flag, &reverse_flag, &infname) == 0)
    exit(1);
    
    /* Open file for reading, if no filename was specified, read from
       stdin */
    rle_names( &hdr, cmd_name( argv ), infname, 0 );
    hdr.rle_file = rle_open_f(hdr.cmd, infname, "r");

    temp = rle_get_setup(&hdr);
    if (temp < 0) {
    fprintf(stderr, "getOrion: error reading setup information from %s\n",
        infname ? infname : "stdin");
    fprintf(stderr, "with return code %d\n", temp);
    exit(1);
    }

    if (debug_flag) rle_debug(1);

    /* a linear map has no gamma correction */
    if (linear_flag) gam = 1.0;

    /* Set up gamma correction table */
    init_gamma_map();

    /* we're only interested in R, G and B */
    RLE_CLR_BIT(hdr, RLE_ALPHA);
    for (i = 3; i < hdr.ncolors; i++)
    RLE_CLR_BIT(hdr, i);
    
    /* Set up rows to point to our copy of the scanline */
    for (i = 0; i < 3; i++)
    rows[i] = scanline[i];

    /* Pretend origin is at 0,0 */
    hdr.xmax -= hdr.xmin;
    hdr.xmin = 0;
    hdr.ymax -= hdr.ymin;
    hdr.ymin = 0;

    /* shift the colour map, if present, down to 8 bits precision */
    for (i = 0; i < hdr.ncmap * (1 << hdr.cmaplen); i++)
    hdr.cmap[i] = hdr.cmap[i] >> 8;

    if (bw_flag) {
    put_mode = MONOCHROME_MODE;
    init_monochrome_colour_map();
    }
    else if ((hdr.ncmap == 3) && hdr.ncolors == 1) {
        /* one channel and 24-bit colour map supplied */
    init_24_bit_colour_map();
    onec_threem_mode = TRUE;
    }
    else
    /* use 216 standard colour map */
    init_8_bit_colour_map();

    /* Initialise the device and create window */
    InitGraf();
    window_size_x = hdr.xmax + 1;
    window_size_y = hdr.ymax + 1;
    SetRect (&r, 50, 50, window_size_x, window_size_y);
    if (infname == NULL)
    window_name = "piped";
    else {
    window_name = infname;
    }
    rle_window = NewWindow(NIL, r, window_name, VISIBLE, noGrowDocProc, FRONT,
             GOAWAY, 0, 7);
    PenPat(black);
    UpdateWindow(rle_window, TRUE);
    write_colour_map();

    /* make the scan line bit map */
    scanbitmap = NewRBitMap(window_size_x, 1, 8);  /* really need only one pla
ne */

    /* Get the scanlines */
    for (i = hdr.ymin; i <= hdr.ymax; i++) {
    rle_getrow(&hdr, rows);
    if (put_mode == MONOCHROME_MODE)
        put_line_mono(i);
    else
        put_line_8(i);
    }

    /* loop */
    EventLoop();
}

MyActivate

(

)

Definition at line 617 of file get_orion.c.

{
    WindowPtr theWindow;
    Bool theState;

    theWindow = (WindowPtr) myEvent.message;
    theState = (myEvent.modifiers & activateFlag) != 0;
    if (theState)
    {
    if (!isActive)
    {
        HiliteWindow (theWindow, TRUE);
        SetPort (theWindow);
        isActive = TRUE;
    }
    }
    else
    {
    HiliteWindow (theWindow, FALSE);
    isActive = FALSE;
    }
}

MyClose

(

)

Definition at line 610 of file get_orion.c.

{
    exit (0);
}

put_line_8

(

int

yscan

)

Definition at line 318 of file get_orion.c.

{
    unsigned char *r, *g, *b;
    int i, dither_col, dither_row;
    int xmax = hdr.xmax;
    int g_offset, b_offset;
    unsigned char *dest_pixel_ptr;

    /* treat 1 colour and 3 colmap channels as special case */
    if (onec_threem_mode) {
    bcopy(rows[0], dest_pixels, xmax+1);
    write_scanline(yscan);
    return;
    }

    dither_row = yscan % 16;
    dither_col = 0;
    dest_pixel_ptr = dest_pixels;
    r = rows[0];
    /* check if we have less than three colour channels */
    g = rows[(hdr.ncolors >= 2 ? 1 : 0)];
    b = rows[(hdr.ncolors >= 3 ? 2 : 0)];

    /* RLE file with colour map */
    if (hdr.ncmap) {
    /* offsets to the green and blue sections of the map */
    g_offset = 1 << hdr.cmaplen;
    b_offset = 2 * g_offset;

    for (i = 0; i <= xmax; i++, r++, g++, b++,
                  dither_col = ((dither_col + 1) & 15),
                  dest_pixel_ptr++)
        *dest_pixel_ptr =
          DMAP(hdr.cmap[*r], dither_col, dither_row) +
          DMAP(hdr.cmap[*g + g_offset], dither_col,
                    dither_row) * 6 +
          DMAP(hdr.cmap[*b + b_offset], dither_col,
                    dither_row) * 36;
    }
    
    else 
    for (i = 0; i <= xmax; i++, r++, g++, b++,
                  dither_col = ((dither_col + 1) & 15),
                  dest_pixel_ptr++) {
        *dest_pixel_ptr =
          DMAP(*r, dither_col, dither_row) +
          DMAP(*g, dither_col, dither_row) * 6 +
          DMAP(*b, dither_col, dither_row) * 36;
        }

    /* Write the scanline to the device */
    write_scanline(yscan);
}

put_line_mono

(

int

yscan

)

Definition at line 380 of file get_orion.c.

{
    unsigned char *r, *g, *b;
    int i, dither_col, dither_row;
    unsigned char *dest_pixel_ptr;
    int xmax = hdr.xmax;
    int bw_val;
    int g_offset, b_offset;

    dither_row = yscan % 16;
    dither_col = 0;
    dest_pixel_ptr = dest_pixels;

    r = rows[0];
    /* check if we have less than three colour channels */
    g = rows[(hdr.ncolors >= 2 ? 1 : 0)];
    b = rows[(hdr.ncolors >= 3 ? 2 : 0)];

    /* RLE file with colour map */
    if (hdr.ncmap) {
    /* offsets in table */
    g_offset = 1 << hdr.cmaplen;
    b_offset = 2 * g_offset;

    for (i = 0; i <= xmax; i++, r++, g++, b++,
                  dither_col = ((dither_col + 1) & 15),
                  dest_pixel_ptr++) {
        bw_val =
        (35 * hdr.cmap[*r] +
         55 * hdr.cmap[*g + g_offset] +
         10 * hdr.cmap[*b + b_offset]) / 100;
        *dest_pixel_ptr = DMAP(bw_val, dither_col, dither_row);
        }
    }

    /* Gamma correction is the default */
    else 
    for (i = 0; i <= xmax; i++, r++, g++, b++,
                  dither_col = ((dither_col + 1) & 15),
                  dest_pixel_ptr++) {
        bw_val =
        (35*(*r) + 55*(*g) + 10*(*b)) / 100;
        *dest_pixel_ptr =
        DMAP(bw_val, dither_col, dither_row);
        }

    /* write the scanline */
    write_scanline(yscan);
}

translate_bits	(	BitMapPtr	db,
		Rect	dr
	)

Definition at line 511 of file get_orion.c.

{
    Ptr sa = scanbitmap.baseAddr;
    unsigned sw = scanbitmap.rowBits;
    Ptr da = db->baseAddr;
    int dy = top(dr);
    unsigned dw = db->rowBits;
    unsigned dh = db->colBits;
    unsigned dps = db->planeSize;
    int cw = width (db->bounds);
    int ch = height (db->bounds);
    unsigned w = window_size_x;
    int *scanad;
    unsigned char *srcad;
    register int dest;
    int bitpos, bytes_in_source;
    int plane = 7;  /* all planes are of interest */

    while(plane+1) {
    scanad = scanbitmap.baseAddr; /* baseAddr is always word-aligned */
    srcad = dest_pixels;
    bitpos = dest = 0;
    bytes_in_source = window_size_x;
    
    while(bytes_in_source){
        /* *srcad++ >> plane is a logical shift */
        dest = dest | (((*srcad++ >> plane) & 0x01) << bitpos);
        if (bitpos++ == 31) {
        *scanad++ = dest;
        dest = bitpos = 0;
        }
        bytes_in_source--;
    }
    *scanad = dest; /* might be some residue */

    /* raster op the translated scanline to the plane in window */
    rasterop(sa, sw, 1, 0, 0,
        da, dw, dh, 1, 23, cw, ch,
        0, dy, w, 1, srcCopy);

    plane--;
    da += dps;
    }
}

write_colour_map

(

)

Definition at line 442 of file get_orion.c.

References all_colours_flag, colmap, gammamap, and n_colmap_colours.

{
    int cltable[256], i;
    int *cltp = cltable;  /* to avoid warning */
    int terminate;
    
    /* Need to preserve colours 240-255 by default */
    if (all_colours_flag)
    terminate = 256;
    else {
    /* read in current CLT */
    ReadCLT(cltp);
    terminate = (n_colmap_colours < 240 ? n_colmap_colours : 240);
    }

    /* create the colour look up table, changing only required number of
       colours, and gamma correcting  */
    for (i = 0; i < terminate; i++)
    cltable[i] = (gammamap[colmap[i][0]] << 16) + 
        (gammamap[colmap[i][1]] << 8) + 
        gammamap[colmap[i][2]];
    
  /* Write it to the device */ 
   WriteCLT(cltp);
}

write_scanline

(

int

yscan

)

Definition at line 475 of file get_orion.c.

{
    if (!reverse_flag)
    yscan = hdr.ymax - yscan;

    /* the following may seem like a long-winded way of doing things, 
     * but it's a lot quicker than setting points and lines with the usual 
     * routines   .
     */

    /* set destination rectangle */
    SetRect(&trandr, 0, yscan, window_size_x, 1);
 
   /* translate the scanline data to the corresponding strip in the
       window */
    translate_bits(&((*rle_window).port.portBits), trandr);

    /* add strip to the update list of window and update */
    AddUpdate(rle_window, trandr, 255);
    UpdateWindow(rle_window, TRUE);
}

Variable Documentation

boolean all_colours_flag = FALSE

Definition at line 60 of file get_orion.c.

Referenced by write_colour_map().

int colmap[256][3]

Definition at line 67 of file get_orion.c.

boolean debug_flag = FALSE

Definition at line 79 of file get_orion.c.

unsigned char dest_pixels[1280]

Definition at line 40 of file get_orion.c.

int divN[256]

Definition at line 51 of file get_orion.c.

int dm16[16][16]

Definition at line 48 of file get_orion.c.

int errN[256]

Definition at line 51 of file get_orion.c.

float gam = 2.0

Definition at line 55 of file get_orion.c.

boolean gamma_flag = FALSE

Definition at line 59 of file get_orion.c.

int gammamap[256]

Definition at line 54 of file get_orion.c.

rle_hdr* hdr

Definition at line 34 of file get_orion.c.

boolean isActive = FALSE

Definition at line 75 of file get_orion.c.

boolean linear_flag = FALSE

Definition at line 58 of file get_orion.c.

EventRecord myEvent

Definition at line 71 of file get_orion.c.

Point myPt

Definition at line 73 of file get_orion.c.

int n_colmap_colours

Definition at line 66 of file get_orion.c.

Referenced by init_24_bit_colour_map(), init_8_bit_colour_map(), init_monochrome_colour_map(), and write_colour_map().

boolean onec_threem_mode = FALSE

Definition at line 86 of file get_orion.c.

int put_mode = 2

Definition at line 63 of file get_orion.c.

boolean reverse_flag = FALSE

Definition at line 82 of file get_orion.c.

WindowPtr rle_window

Definition at line 70 of file get_orion.c.

unsigned char * rows[4]

Definition at line 37 of file get_orion.c.

BitMap scanbitmap

Definition at line 43 of file get_orion.c.

unsigned char scanline[4][1280]

Definition at line 37 of file get_orion.c.

int thePart

Definition at line 74 of file get_orion.c.

Rect trandr

Definition at line 44 of file get_orion.c.

WindowPtr whichWindow

Definition at line 72 of file get_orion.c.

int window_size_x

Definition at line 76 of file get_orion.c.

int window_size_y

Definition at line 76 of file get_orion.c.