pr_test.c

操作系统SunOS 4.1.3版本的源码

#ifndef lint
static  char sccsid[] = "@(#)pr_test.c 1.1 92/07/30 Copyr 1990 Sun Micro";
#endif

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


/**********************************************************************/
/* Include files */
/**********************************************************************/

#include <stdio.h>
#include <sys/types.h>
#include <sys/timeb.h>
#include <string.h>
#include <pixrect/pixrect_hs.h>
#include <sunwindow/cms_colorcube.h>
#include <sdrtns.h>     /* sdrtns.h should always be included */
#include <esd.h>

#define CHUNK_WIDTH	64
#define CHUNK_HEIGHT	64

/**********************************************************************/
/* External variables */
/**********************************************************************/

extern
int		ierr;

extern
long		random();

extern
char		*sprintf();

extern
char		*initstate(),
		*setstate();

extern
time_t		time();

extern
char		*device_name;

/**********************************************************************/
/* Static variables */
/**********************************************************************/

static
long rand_state[32]  =  {
		   3,  0x9a319039,  0x8999220b,       0x27fb47b9,
	  0x32d9c024,  0x9b663182,  0x5da1f342,       0x7449e56b,
          0xbeb1dbb0,  0xab5c5918,  0x946554fd,       0x8c2e680f,
          0xeb3d799f,  0xb11ee0b7,  0x2d436b86,       0xda672e2a,
          0x1588ca88,  0xe369735d,  0x904f35f7,       0xd7158fd6,
          0x6fa6f051,  0x616e6b96,  0xac94efdc,       0xde3b81e0,
          0xdf0a6fb5,  0xf103bc02,  0x48f340fb,       0x36413f93,
          0xc622c298,  0xf5a42ab8,  0x8a88d77b,       0xf5ad9d0e, };

static
time_t		ltime;


/**********************************************************************/
char *pr_test(pr, mask)
/**********************************************************************/
Pixrect *pr;
register int mask;
/* Test the pixrect memory by writing a random pattern to it */

{
    static char errtxt[256];
    Pixrect	*mprs = (Pixrect *) NULL,
		*mprd = (Pixrect *) NULL,
		*mpr_save = (Pixrect *) NULL;

    register *iptr;
    register int i;
    register int j;
    register int k;
    register int pps;
    register int rest;
    int chunk_width = CHUNK_WIDTH;
    int chunk_width_rest;
    int chunk_height = CHUNK_HEIGHT;
    int chunk_height_rest;
    int nx;
    int ny;


    func_name = "pr_test";
    TRACE_IN

    /* initialize state of the random generator */
    ltime = time((time_t *)0);
    (void)initstate((unsigned int)ltime, (char *)rand_state, 128);
    (void)setstate((char *)rand_state);

    /* create memory pixrect to save the original screen */
    mpr_save = mem_create(chunk_width, chunk_height, pr->pr_depth);
    if (mpr_save == NULL) {
	(void)strcpy(errtxt, errmsg_list[31]);
	goto error_return;
    }

    /* create memory pixrect to puit random patterns */
    mprs = mem_create(chunk_width, chunk_height, pr->pr_depth);
    if (mprs == NULL) {
	(void)strcpy(errtxt, errmsg_list[31]);
	goto error_return;
    }
    pps = (chunk_width * chunk_height * pr->pr_depth)/
						    (sizeof(int) << 3);
    iptr = (int *)mpr_d(mprs)->md_image;

    for (i = 0 ; i < pps - 1 ; i++) {
	*iptr++ = random();
    }
    if ((rest = pps % sizeof(int))) {
	char *cp = (char *)iptr;
	for (i = rest ; i > 0 ; i--) {
	    *cp++ = (char)random();
	}
    } else {
	*iptr = random() & mask;
    }

    mprd = mem_create(chunk_width, chunk_height, pr->pr_depth);
    if (mprd == NULL) {
	(void)strcpy(errtxt, errmsg_list[31]);
	goto error_return;
    }

    /* calculate number of loops */
    nx = pr->pr_width / chunk_width;
    chunk_width_rest = pr->pr_width % chunk_width;
    if (chunk_width_rest)
	nx++;
    else
	chunk_width_rest = chunk_width;	
    ny = pr->pr_height / chunk_height;
    chunk_height_rest = pr->pr_height % chunk_height;
    if (chunk_height_rest)
	ny++;
    else
	chunk_height_rest = chunk_height;

    for (i = 0 ; i < ny ; i++) {
        int pr_y = i*chunk_height;
	if (i == ny-1) chunk_height = chunk_height_rest;
	for (j = 0 ; j < nx ; j++) {
	    int pr_x = j*chunk_width;
	    if (j == nx-1) chunk_width = chunk_width_rest;

	    pps = (chunk_width * chunk_height * pr->pr_depth)/
						    (sizeof(int) << 3);
	    (void)check_key();

	    /* save the current screen */
	    (void)pr_rop (mpr_save, 0, 0, chunk_width, chunk_height,
				PIX_SRC | PIX_DONTCLIP, pr, pr_x, pr_y);

	    /* write pattern to pixrect device */
	    (void)pr_rop (pr, pr_x, pr_y, chunk_width, chunk_height,
				    PIX_SRC | PIX_DONTCLIP, mprs, 0, 0);

	    /* copy screen into memory pixrect */
	    (void)pr_rop (mprd, 0, 0, chunk_width, chunk_height,
				PIX_SRC | PIX_DONTCLIP, pr, pr_x, pr_y);

	    /* restore previous screen */
	    (void)pr_rop (pr, pr_x, pr_y, chunk_width, chunk_height,
				PIX_SRC | PIX_DONTCLIP, mpr_save, 0, 0);

	    /* Xor pixrect device with pattern */
	    (void)pr_rop (mprd, 0, 0, chunk_width, chunk_height,
			(PIX_SRC ^ PIX_DST) | PIX_DONTCLIP, mprs, 0, 0);

	    iptr = (int *)mpr_d(mprd)->md_image;
	    if ((rest= pps % sizeof(int))) pps--;
	    for (k = 0 ; k < pps ; k++) {
		if (*iptr & mask) {
		    (void)sprintf(errtxt, errmsg_list[32], (iptr-(int *)mpr_d(mprd)->md_image)*sizeof(int));
		    goto error_return;
		}
		iptr++;
	    }

	    if (rest) {
		char *cp = (char *)iptr;
		for (k = rest ; k > 0 ; k--) {
		    if (*cp) {
			(void)sprintf(errtxt, errmsg_list[32], cp-(char *)mpr_d(mprd)->md_image);
			goto error_return;
		    }
		    cp++;
		}
	    }
	}
    }

    (void)pr_close(mprs);
    (void)pr_close(mprd);
    (void)pr_close(mpr_save);

    TRACE_OUT
    return((char *)0);

    /* return point for errors */
    error_return:
	if (mprs) {
	    (void)pr_close(mprs);
	}
	if (mprd) {
	    (void)pr_close(mprd);
	}
	if (mpr_save) {
	    (void)pr_close(mpr_save);
	}

	TRACE_OUT
	return(errtxt);

}

/**********************************************************************/
char *pr_visual_test(pr)
/**********************************************************************/
Pixrect *pr;

{
    register unsigned int pat, *cp;
    int current_plane;
    int current_attr;
    Pixrect *line;
    int i, j, k;

    func_name = "pr_visual_test";
    TRACE_IN

    /* save current settings */
    current_plane = pr_get_plane_group(pr);
    (void)pr_getattributes(pr, &current_attr);

    /* set 24-bit plane group and attributes */
    (void)pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);

    line = mem_create(pr->pr_size.x, 64, pr->pr_depth);
    if (line == NULL) {

	TRACE_OUT
	return(errmsg_list[31]);
    }

    /*
    (void)pr_clear_all(pr);
    */

    /* create 64 lines of chess board pattern */
    cp = (unsigned int *)(mpr_d(line)->md_image);
    for ( k = 0 ; k < 64 ; k++) {
	/* create one line chess board pattern */
	pat = 0;
	for (i = 0 ; i < pr->pr_size.x/64 ; i++ ) {
	    for (j = 0 ; j < (64*pr->pr_depth)/(sizeof(int)*8) ; j++) {
		*cp = pat;
		cp++;
	    }
	    pat = ~pat;
	}
    }

    for (i = 0 ; i < pr->pr_size.y/64 ; i++) {
	if (i % 2) {
	    (void)pr_rop(pr, 0, i*64, pr->pr_size.x, line->pr_size.y,
					PIX_NOT(PIX_SRC), line, 0, 0);
	} else {
	    (void)pr_rop(pr, 0, i*64, pr->pr_size.x, line->pr_size.y, PIX_SRC,
							    line, 0, 0);
	}
    }
				
    /* restore original settings */
    pr_set_planes(pr, current_plane, current_attr);

    (void)pr_close(line);

    sleep(10);

    TRACE_OUT
    return((char *)0);
}

#define XBGR(r,g,b) (((b)<<16) + ((g)<<8) + (r))
/**********************************************************************/
pr_rgb_stripes(pr)
/**********************************************************************/
Pixrect *pr;
/* generates three rows of red, green and blues bars on screen */

{
   int state;
   int level;
   int cr;
   int temp;
   int color;
   int x;
   int y;

    func_name = "pr_rgb_stripes";
    TRACE_IN

   for (state = 0; state < 3; state++) {
        for (level = 0; level < 8; level++) {
            for (cr = 0; cr < 32; cr++) {
                temp = cr + level * 32;
                switch (state) {
                case 0:
                    color = XBGR(temp, 0, 0);
                    break;
                case 1:
                    color = XBGR(0, temp, 0);
                    break;
                case 2:
                    color = XBGR(0, 0, temp);
                    break;
                }
                x = cr * 36;
                y = state * 256 + level * 32;
                (void)pr_rop(pr, x, y, 36, 32, (PIX_SRC |
				PIX_COLOR(color)), (Pixrect *)0, 0, 0);
            }
        }
    }

    TRACE_OUT
    return 0;
}

/**********************************************************************/
char *
pixrect_complete_test(pr)
/**********************************************************************/
Pixrect *pr;
/* Device-dependent frame buffer test. This test covers the
 * double buffering and all plane groups */

{
    extern char *pr_all_test();
    static char errtxt[256];
    struct fb_wid_alloc wid;
    char *errmsg;
    int current_state;

    func_name = "pixrect_complete_test";
    TRACE_IN

    /* Determine if frame buffer has double buffering  capability */
    if (pr_dbl_get(pr, PR_DBL_AVAIL) == PR_DBL_EXISTS) {
	/* switch to both buffers*/
	/* allocate WID for 24-bit buffer */
	wid.wa_type = FB_WID_SHARED_24;
	wid.wa_count = 1;
	if (pr_ioctl(pr, FBIO_WID_ALLOC, &wid) < 0) {
	    return errmsg_list[50];
	}
	pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
	pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_BOTH,
			PR_DBL_WRITE, PR_DBL_BOTH,
			PR_DBL_READ, PR_DBL_BOTH,
			PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_BOTH,
			0);
	/* we run this test only if both buffers can be
	   written at the same time */
	if (pr_dbl_get(pr, PR_DBL_WRITE) == PR_DBL_BOTH) {
	    errmsg = pr_all_test(pr, PIXPG_INVALID);
	    if (errmsg) {
		(void)strcpy(errtxt, errmsg_list[35]);
		(void)strcat(errtxt, errmsg);
		TRACE_OUT
		return errtxt;
	    }
	    pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
	    pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_B,
			PR_DBL_WRITE, PR_DBL_BOTH,
			PR_DBL_READ, PR_DBL_BOTH,
			PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_B,
			0);
	    errmsg = pr_all_test(pr, PIXPG_INVALID);
	    if (errmsg) {
		(void)strcpy(errtxt, errmsg_list[36]);
		(void)strcat(errtxt, errmsg);
		TRACE_OUT
		return errtxt;
	    }
	}

	/* allocate WID for duble buffer */
	wid.wa_type = FB_WID_DBL_24;
	wid.wa_count = 1;
	if (pr_ioctl(pr, FBIO_WID_ALLOC, &wid) < 0) {
	    return errmsg_list[50];
	}
	/* save current display buffer */
	current_state = pr_dbl_get(pr, PR_DBL_DISPLAY);
	/* switch to buffer A */
	pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
	pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_B,
			PR_DBL_WRITE, PR_DBL_A,
			PR_DBL_READ, PR_DBL_A,
			PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_B,
			0);
	errmsg = pr_all_test(pr, PIXPG_8BIT_COLOR);
	if (errmsg) {
	    (void)strcpy(errtxt, errmsg_list[33]);
	    (void)strcat(errtxt, errmsg);