pr_test.c

操作系统SunOS 4.1.3版本的源码

    TRACE_OUT

}

/**********************************************************************/
exclude_plane_group(plane)
/**********************************************************************/
int plane;
{

    func_name = "exclude_plane_group";
    TRACE_IN

    groups[plane] = FALSE;

    TRACE_OUT

}

/**********************************************************************/
include_plane_group(plane)
/**********************************************************************/
int plane;
{

    func_name = "include_plane_group";
    TRACE_IN

    groups[plane] = TRUE;

    TRACE_OUT

}

/**********************************************************************/
get_plane_group(plane)
/**********************************************************************/
int plane;
{

    func_name = "get_plane_group";
    TRACE_IN

    TRACE_OUT
    return(groups[plane]);


}


/**********************************************************************/
char *
pr_all_test(pr)
/**********************************************************************/
Pixrect *pr;
/* tests all pixrect planes */

{
    static char errtxt[512];
    int i;
    int mask;
    int current_plane;
    int current_attr;
    char *errmsg;
    int err = 0;
    
    func_name = "pr_all_test";
    TRACE_IN

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

    for (i = 0 ; i <= ngroups ; i++) {
	if (get_plane_group(i)) {
	    pr_set_planes(pr, i, PIX_ALL_PLANES);

	    /* set the test mask accordingly,
	       not all bits are valid for every plane */
	    switch (i) {
		case PIXPG_24BIT_COLOR :
		    mask = 0xffffff; /* 24-bit color XRGB format */
		    break;
		case PIXPG_WID :
		    mask = 0x3ff;   /* 10-bit WID */
		    break;
		case PIXPG_ZBUF :
		    mask = 0x00ffffff;	 /* 24-bit ZBUFF */
		    break;
		default :
		    mask = 0xffffffff;   /* everthing else should be
					    8-bit or 1-bit deep */
	    }

	    errmsg = pr_test(pr, mask);
	    if (errmsg) {
    		/* restore original settings */
    		pr_set_planes(pr, current_plane, current_attr);
		(void)strcpy(errtxt, groupnames[i]);
		(void)strcat(errtxt, ", ");
		(void)strcat(errtxt, errmsg);
		(void)strcat(errtxt, ".\n");
		TRACE_OUT
		return (errtxt);
    	    } 
	}
    }

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

    TRACE_OUT
    return (char *)0;
}

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

{
    

    static char errtxt[256];
    char *color_table_test();
    static int pg[] = {  PIXPG_8BIT_COLOR,
                         PIXPG_24BIT_COLOR,
			 PIXPG_INVALID,
                        };
    static char *pg_names[] = {
                            "8BIT COLOR",
                            "24BIT COLOR",
			    "",
                        };

    int current_plane;
    int current_attr;
    int current_clut_id;

    int j;
    int n;
    char *errmsg;

    func_name = "lut_test";
    TRACE_IN

    current_plane = pr_get_plane_group(pr);
    (void)pr_getattributes(pr, &current_attr);

 
    for (j = 0 ; pg[j] != PIXPG_INVALID ; j++) {
        /* set plane group and attributes */
        (void)pr_set_planes(pr, pg[j], PIX_ALL_PLANES);

	if (pg[j] == PIXPG_8BIT_COLOR) {
	    current_clut_id = get_clut_id(pr);
	    for (n = 0 ; n < 14 ; n++) {
		set_clut_id(pr, n);
		errmsg = color_table_test(pr, 0, PR_DONT_DEGAMMA);
		if (errmsg) {
		    sprintf(errtxt, DLXERR_CLUT_TEST, pg_names[j], n, errmsg);
		    return errtxt;
		}
	    }
	    set_clut_id(pr, current_clut_id);
	} else {
	    errmsg = color_table_test(pr, PR_FORCE_UPDATE, PR_DONT_DEGAMMA);
		if (errmsg) {
		    sprintf(errtxt, DLXERR_CLUT_TEST, pg_names[j], 0, errmsg);
		    return errtxt;
		}
	}
    }
 
    /* restore original settings */
    pr_set_planes(pr, current_plane, current_attr);

    (void)pr_rgb_stripes(pr);
    sleep(15);

    (void)pr_clear_all(pr);


    TRACE_OUT
    return (char *)0;

}

/**********************************************************************/
get_clut_id (pr)
/**********************************************************************/
Pixrect *pr;
{

    int clutid;

    func_name = "get_clut_id";
    TRACE_IN

    clutid = ((struct gt_data *)((pr)->pr_data))->clut_id;

    TRACE_OUT

    return clutid;
}

/**********************************************************************/
set_clut_id (pr, n)
/**********************************************************************/
Pixrect *pr;
int n;

{

    func_name = "set_clut_id";
    TRACE_IN

    ((struct gt_data *)((pr)->pr_data))->clut_id = n;

    TRACE_OUT

}

/**********************************************************************/
char *
color_table_test(pr, pr_force_update, pr_dont_degamma)
/**********************************************************************/
Pixrect *pr;
int pr_force_update;
int pr_dont_degamma;
{

    static char errtxt[256];
    unsigned char sred[256], sgreen[256], sblue[256];
    unsigned char *red, *green, *blue;
    unsigned int wlut[192];
    unsigned int rlut[192];
    int llength = 256;
    int i;
 

    func_name = "color_table_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);

    /* preset test pattern in memory */
    for (i=0 ; i < 192 ; i++) {
        wlut[i] = random();
    }


    /* save the original colormap */
    (void)pr_getlut(pr, 0, llength, sred, sgreen, sblue);
 
    /* write to lut memory */
    red = (unsigned char *)&(wlut[0]);
    green = red + 256;
    blue = green + 256;
    (void)gt_putlut_blocked(pr, 0|pr_force_update|pr_dont_degamma, llength, red, green, blue);

    /* read from lut memory */
    red = (unsigned char *)&(rlut[0]);
    green = red + 256;
    blue = green + 256;
    (void)pr_getlut(pr, 0|pr_dont_degamma, llength, red, green, blue);
 
    /* restore original colormap */
    (void)gt_putlut_blocked(pr, 0|pr_force_update, llength, sred, sgreen, sblue);
 
    for (i=0 ; i < (llength*3)/sizeof(int) ; i++) {
	if (rlut[i] != wlut[i]) {
	    (void)sprintf(errtxt, DLXERR_LOOKUP_TABLE, i*sizeof(int), wlut[i], rlut[i]);
	    TRACE_OUT
	    return errtxt;
	}
    }

    TRACE_OUT

    return (char *)0;
}

/**********************************************************************/
pr_clear(pr, op)
/**********************************************************************/
Pixrect *pr;
int op;
/* clear current pixrect plane */
{
    
    func_name = "pr_clear";
    TRACE_IN

    (void)pr_rop(pr, 0, 0, pr->pr_size.x, pr->pr_size.y, op,
					(Pixrect *)NULL, NULL, NULL);
    TRACE_OUT
}
/**********************************************************************/
pr_clear_all(pr)
/**********************************************************************/
Pixrect *pr;
/* clear all available pixrect planes */
{
    char groups[PIXPG_INVALID+1];
    int i;
    int op;
    unsigned char red[256];
    unsigned char green[256];
    unsigned char blue[256];

    func_name = "pr_clear_all";
    TRACE_IN

    (void)get_available_plane_groups(pr);
    (void)exclude_plane_group(PIXPG_WID);

    pr_set_planes(pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
    (void)pr_dbl_set(pr, PR_DBL_DISPLAY, PR_DBL_B,
		    PR_DBL_WRITE, PR_DBL_B,
		    PR_DBL_READ, PR_DBL_B,
		    PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_B,
		    0);
    for (i = 0 ; i < ngroups ; i++) {
	if (get_plane_group(i)) {
	    pr_set_planes(pr, i, PIX_ALL_PLANES);
	    op = PIX_CLR;
	    (void)pr_clear(pr, op);
	}
    }
    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);
    for (i = 0 ; i < ngroups ; i++) {
	if (get_plane_group(i)) {
	    pr_set_planes(pr, i, PIX_ALL_PLANES);
	    op = PIX_CLR;
	    (void)pr_clear(pr, op);
	}
    }

    TRACE_OUT
}
/**********************************************************************/
gt_putlut_blocked(pr, index, count, red, green, blue)
/**********************************************************************/
Pixrect		*pr;
int		index, count;
unsigned char	*red, *green, *blue;
{
    struct gt_data	*gtd;
    struct fb_clut	fbclut;
    struct fbcmap	fbmap;
    int			plane;
    int			res;
    

    func_name = "gt_putlut_blocked";
    TRACE_IN

    gtd = (struct gt_data *) gt_d(pr);
    /* Extract the plane if necessary */


    if (PIX_ATTRGROUP(index))
    {
        plane = PIX_ATTRGROUP(index) & PIX_GROUP_MASK;
        index &= PR_FORCE_UPDATE | PIX_ALL_PLANES;  
    }
    else
        plane = gtd->planes;
    
    if (PIX_ATTRGROUP(plane) == PIXPG_8BIT_COLOR)
         fbclut.index = gtd->clut_id;
    else if (PIX_ATTRGROUP(plane) == PIXPG_24BIT_COLOR){
        if (index & PR_FORCE_UPDATE)
            fbclut.index = GT_CLUT_INDEX_24BIT;
        else
            return(0);
    }
    else if ((PIX_ATTRGROUP(plane) == PIXPG_CURSOR)||
            (PIX_ATTRGROUP(plane) == PIXPG_CURSOR_ENABLE)){
        /* never post to cusor lut */
        return (0);
    }
    else
        return PIX_ERR;

   fbclut.flags = FB_BLOCK; 

#ifdef KERNEL
    fbclut.flags |= FB_KERNEL;        
#else
    /* If neither of these are set use the system default */
    if (index & PR_DONT_DEGAMMA) {
        fbclut.flags |= FB_NO_DEGAMMA;
    } else if (index & PR_DEGAMMA) {
        fbclut.flags |= FB_DEGAMMA;
    }
#endif  
    fbclut.count  = count;
    fbclut.offset  = index & ~(PR_FORCE_UPDATE|PR_DONT_DEGAMMA|PR_DEGAMMA);
    fbclut.red    = red;
    fbclut.green  = green;
    fbclut.blue   = blue;

    res = ioctl(gtd->fd, FB_CLUTPOST, (caddr_t) &fbclut, 0);

    TRACE_OUT
    return res;
}