pr_test.c

操作系统SunOS 4.1.3版本的源码

		    /* don't print bank number if in byte or stencil mode since
		       the write are packed into 4 bytes */
		    if (mask != 0xffffffff)
		    	(void)sprintf(errtxt, DLXERR_PIXEL_MODE_AT, scr_x, scr_y,
                                      bank,*wptr&mask, *rptr&mask, (*wptr^*rptr)&mask);
		    else
		    	(void)sprintf(errtxt, DLXERR_BYTE_MODE_AT, scr_x, scr_y,
                                      *wptr, *rptr, *wptr ^ *rptr);

		    err++;
		}

		/* verify complement */
		if (((*wptr ^ *cptr) & mask) != mask) {

		    /* don't print bank number if in byte or stencil mode since
		       the write are packed into 4 bytes */
		    if (mask != 0xffffffff)
		    	(void)sprintf(errtxt2, DLXERR_PIXEL_MODE_AT, scr_x, scr_y,
                                      bank,~(*wptr)&mask, *cptr&mask, (~(*wptr) ^ *cptr)&mask);
		    else
		    	(void)sprintf(errtxt2, DLXERR_BYTE_MODE_AT, scr_x, scr_y,
                                      ~(*wptr)&mask, *cptr&mask, (~(*wptr) ^ *cptr)&mask);
		    err++;
		    (void)strcat(errtxt, errtxt2);
		}

		if (err) goto error_return;

		cptr++;
		wptr++;
		rptr++;
	    }

	    if (rest) {

		char *wpc = (char *)wptr;
		char *rpc = (char *)rptr;
		char *cpc = (char *)cptr;

		for (k = rest ; k > 0 ; k--) {

	   	    scr_x = pr_x + (k % chunk_width);
	   	    scr_y = pr_y + (k / chunk_width);
		    bank  = scr_x % NBANK;

		    if (*wpc ^ *rpc) {

		    	/* don't print bank number if in byte or stencil mode
		           the writes are packed into 4 bytes */
		    	if (mask != 0xffffffff)
		    		(void)sprintf(errtxt, DLXERR_PIXEL_MODE_AT, scr_x, scr_y,
                                      bank,*wpc, *rpc, *wpc ^ *rpc);
		    	else
		    		(void)sprintf(errtxt, DLXERR_BYTE_MODE_AT, scr_x, scr_y,
                                      *wpc, *rpc, *wpc ^ *rpc);
		    	err++;
		    }

		    /* testing complement */
		    if ((*wpc ^ *cpc) != 0xffff) {
		    	/* don't print bank number if in byte or stencil mode
		           the writes are packed into 4 bytes */
		    	if (mask != 0xffffffff)
		    		(void)sprintf(errtxt, DLXERR_PIXEL_MODE_AT, scr_x, scr_y,
                                      bank, ~(*wpc), *cpc, ~(*wpc) ^ *cpc);
		    	else
		    		(void)sprintf(errtxt, DLXERR_BYTE_MODE_AT, scr_x, scr_y,
                                      ~(*wpc), *cpc, ~(*wpc) ^ *cpc);
		    	err++;
		    }

		    if (err) goto error_return;

		    wpc++;
		    rpc++;
		    cpc++;
		}
	    }
	}
    }

    (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 (mprc) {
	    (void)pr_close(mprc);
	}
	if (mpr_save) {
	    (void)pr_close(mpr_save);
	}

	TRACE_OUT
	return(errtxt);

}

#define GREY_LEVEL 0x70707070
/**********************************************************************/
char *pr_visual_test(pr)
/**********************************************************************/
Pixrect *pr;

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

    func_name = "pr_visual_test";
    TRACE_IN

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

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

    /* make it visible */
/*
    (void)pr_set_planes(pr, PIXPG_WID, PIX_ALL_PLANES);
    op = PIX_SRC | PIX_COLOR(wid_alloc(pr, FB_WID_DBL_8));
    (void)pr_clear(pr, op);
*/

    /* set 8-bit plane group and attributes */
    (void)pr_set_planes(pr, PIXPG_8BIT_COLOR, PIX_ALL_PLANES);
    (void)pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_A,
		    PR_DBL_WRITE, PR_DBL_A,
		    PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_A,
		    0);

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

	TRACE_OUT
	return(DLXERR_OPEN_MEM_PIXRECT);
    }

    /* 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 = GREY_LEVEL;
	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);

    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 */

{
    unsigned char red[256];
    unsigned char green[256];
    unsigned char blue[256];
    int state;
    int level;
    int current_plane;
    int current_attr;
    int op;
    int cr;
    int temp;
    int color;
    int x;
    int y;
    int i;

    func_name = "pr_rgb_stripes";
    TRACE_IN


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

    (void)pr_clear_all(pr);
    /* make it visible */
    (void)pr_set_planes(pr, PIXPG_WID, PIX_ALL_PLANES);
    op = PIX_SRC | PIX_COLOR(wid_alloc(pr, FB_WID_DBL_24));
    op = pr_clear(pr, op);

    /* set 24-bit plane group and attributes */
    (void)pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
    (void)pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_A,
		    PR_DBL_WRITE, PR_DBL_A,
		    PR_DBL_READ, PR_DBL_A,
		    PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_A,
		    0);

    /* load 1-1 color map */
    for (i=0 ; i <256 ; i++) {
	red[i] = green[i] = blue[i] = i;
    }
    (void)pr_putlut(pr, 0, 256, red, green, blue);

    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;
		if (color == 0xff) color = 0xfe;
		if (color == 0xff00) color = 0xfe00;
		if (color == 0xff0000) color = 0xfe0000;
                (void)pr_rop(pr, x, y, 36, 32, (PIX_SRC |
				PIX_COLOR(color)), (Pixrect *)0, 0, 0);
            }
        }
    }

    /* restore original settings */
    pr_set_planes(pr, current_plane, current_attr);

    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];
    char *errmsg;
    int current_state;
    int err=0;

    func_name = "pixrect_complete_test";
    TRACE_IN

    pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);

    if (pr_dbl_get(pr, PR_DBL_AVAIL) == PR_DBL_EXISTS) {
	/* save current display buffer */
	current_state = pr_dbl_get(pr, PR_DBL_DISPLAY);

	/* switch to both buffers*/
	pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
	pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_A,
			PR_DBL_WRITE, PR_DBL_BOTH,
			PR_DBL_READ, PR_DBL_A,
			PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_A,
			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);
	    if (errmsg) {
		(void)strcpy(errtxt, DLXERR_SIMULT_WRITE_BOTH_READ_A);
		(void)strcat(errtxt, errmsg);
		error_report(errtxt);
		err++;
	    }

	    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_B,
			PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_B,
			0);
	    errmsg = pr_all_test(pr);
	    if (errmsg) {
		(void)strcpy(errtxt, DLXERR_SIMULT_WRITE_BOTH_READ_B);
		(void)strcat(errtxt, errmsg);
		error_report(errtxt);
		err++;
	    }
	}

	/* 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);
	if (errmsg) {
	    (void)strcpy(errtxt, DLXERR_BUFF_A);
	    (void)strcat(errtxt, errmsg);
	    error_report(errtxt);
	    err++;
	}

	/* switch to buffer B */
	pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
	pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_A,
			PR_DBL_WRITE, PR_DBL_B,
			PR_DBL_READ, PR_DBL_B,
			PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_A,
			0);
	errmsg = pr_all_test(pr);
	if (errmsg) {
	    (void)strcpy(errtxt, DLXERR_BUFF_B);
	    (void)strcat(errtxt, errmsg);
	    error_report(errtxt);
	    err++;
	}

	/* restore original buffer */
	pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
	pr_dbl_set(pr, current_state, 0);

    } else {
	errmsg = pr_all_test(pr);
	if (errmsg) {
	    (void)strcpy(errtxt, DLXERR_PIXRECT);
	    (void)strcat(errtxt, errmsg);
	    error_report(errtxt);
	    err++;
	}
    }


    /* bring up chess board pattern */
/* Do not bring up checker board patter, this just confuses people */
/***
    errmsg = pr_visual_test(pr);
    if (errmsg) {
	(void)strcpy(errtxt, DLXERR_PIXRECT_VISUAL);
	(void)strcat(errtxt, errmsg);
	TRACE_OUT
	return errtxt;
    }
***/

    if (err) {
	sprintf(errtxt, DLXERR_VIDEO_MEMORY_FAILED, err);
	TRACE_OUT
	return(errtxt);
    } else {
	TRACE_OUT
	return (char *)0;
    }
}

/**********************************************************************/
get_available_plane_groups(pr)
/**********************************************************************/
Pixrect *pr;
{
    int i;


    func_name = "get_available_plane_groups";
    TRACE_IN

    for (i = 0 ; i < PIXPG_INVALID ; i++)
	groups[i] = 0;

    ngroups = pr_available_plane_groups(pr, PIXPG_INVALID, groups);