void __glXDisp_PixelMapusv(GLbyte *pc)
{
glPixelMapusv(
*(GLenum *)(pc + 0),
*(GLint *)(pc + 4),
(GLushort *)(pc + 8)
);
}
static void
pixel_map(int on) {
GLushort table[256];
if (on) {
int i;
table[0] = 0;
for (i=1; i<32; i++)
table[i] = 65535;
glPixelMapusv(GL_PIXEL_MAP_R_TO_R, 32, table);
glPixelMapusv(GL_PIXEL_MAP_G_TO_G, 32, table);
glPixelMapusv(GL_PIXEL_MAP_B_TO_B, 32, table);
glPixelTransferi(GL_MAP_COLOR, GL_TRUE);
} else {
glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
glPixelMapusv(GL_PIXEL_MAP_R_TO_R, 1, table);
glPixelMapusv(GL_PIXEL_MAP_G_TO_G, 1, table);
glPixelMapusv(GL_PIXEL_MAP_B_TO_B, 1, table);
}
}
void compute_matte(void)
{
glClear(GL_ACCUM_BUFFER_BIT);
/* draw rectangle in (key color + 1) / 2 */
glBegin(GL_QUADS);
glColor3f(key[0], key[1], key[2]);
glVertex2f(0, 0);
glVertex2f(w, 0);
glVertex2f(w, h);
glVertex2f(0, h);
glEnd();
glFlush();
/* negate & accumulate */
glAccum(GL_LOAD, -1);
/* compute & return (image - key) */
glRasterPos2f(0, 0);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, img0);
glAccum(GL_ACCUM, 1);
glAccum(GL_RETURN, 1);
/* move to right hand side of window */
glRasterPos2f(w, 0);
glCopyPixels(0, 0, w, h, GL_COLOR);
/* compute & return (key - image) */
glEnable(GL_SCISSOR_TEST);
glScissor(0, 0, w, h);
glAccum(GL_MULT, -1);
glAccum(GL_RETURN, 1);
glScissor(0, 0, 2*w, h);
glDisable(GL_SCISSOR_TEST);
/* assemble to get fabs(key - image) */
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_BLEND);
glRasterPos2i(0, 0);
glCopyPixels(w, 0, w, h, GL_COLOR);
glDisable(GL_BLEND);
/* assemble into alpha channel */
{
GLfloat mat[] = {
RW, RW, RW, RW,
GW, GW, GW, GW,
BW, BW, BW, BW,
0, 0, 0, 0,
};
glMatrixMode(GL_COLOR);
glLoadMatrixf(mat);
glRasterPos2i(w, 0);
glCopyPixels(0, 0, w, h, GL_COLOR);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
/* do a second copy because sbias comes after color matrix in the
* transfer pipeline. could avoid this by using the post color matrix
* scale bias... */
if (upperfudge - lowerfudge) {
glPixelTransferf(GL_ALPHA_SCALE, 1./(upperfudge - lowerfudge));
glPixelTransferf(GL_ALPHA_BIAS, -lowerfudge/(upperfudge - lowerfudge));
} else {
/* move such that upper/lowerfudge maps to .5, then quantize with
* 2-entry pixel map. */
GLushort quantize[] = {0, 0xffff};
glPixelTransferf(GL_ALPHA_BIAS, .5 - upperfudge);
glPixelMapusv(GL_PIXEL_MAP_A_TO_A, 2, quantize);
glPixelTransferi(GL_MAP_COLOR, 1);
}
glRasterPos2i(w, 0);
glCopyPixels(w, 0, w, h, GL_COLOR);
glPixelTransferf(GL_ALPHA_SCALE, 1);
glPixelTransferf(GL_ALPHA_BIAS, 0);
glPixelTransferi(GL_MAP_COLOR, 0);
}
/* copy matte to right */
glRasterPos2i(0, 0);
glCopyPixels(w, 0, w, h, GL_COLOR);
/* draw the third image */
glColorMask(1, 1, 1, 0);
glRasterPos2i(w, 0);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, img2);
glColorMask(1, 1, 1, 1);
glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
glEnable(GL_BLEND);
glRasterPos2i(w, 0);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, img1);
/* this is for matte display... */
glColor3f(1, 1, 1);
glBegin(GL_QUADS);
glVertex2f(0, 0);
glVertex2f(w, 0);
glVertex2f(w, h);
glVertex2f(0, h);
glEnd();
glDisable(GL_BLEND);
}
enum piglit_result
test_pixel_map(void *null)
{
int use_unpack;
int use_pack;
GLuint pb_pack[1];
GLuint pb_unpack[1];
int i;
int size;
int max;
GLushort *pbo_mem;
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
glGetIntegerv(GL_MAX_PIXEL_MAP_TABLE, &max);
for (use_pack = 0; use_pack < 2; use_pack++) {
for (use_unpack = 0; use_unpack < 2;
use_unpack++) {
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (use_unpack) {
glGenBuffersARB(1, pb_unpack);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
pb_unpack[0]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
max * sizeof(GLushort), NULL,
GL_STREAM_DRAW);
}
pbo_mem = NULL;
if (use_unpack) {
pbo_mem = (GLushort *) glMapBufferARB(
GL_PIXEL_UNPACK_BUFFER_ARB,
GL_WRITE_ONLY);
}
else {
pbo_mem = (GLushort *)
malloc(sizeof(GLushort) * max);
}
for (i = 0; i < max; i++)
pbo_mem[i] = max - i - 1;
if (use_unpack) {
glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
glPixelMapusv(GL_PIXEL_MAP_R_TO_R, max, NULL);
glPixelMapusv(GL_PIXEL_MAP_G_TO_G, max, NULL);
glPixelMapusv(GL_PIXEL_MAP_B_TO_B, max, NULL);
glPixelMapusv(GL_PIXEL_MAP_A_TO_A, max, NULL);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
0);
}
else {
glPixelMapusv(GL_PIXEL_MAP_R_TO_R, max,
pbo_mem);
glPixelMapusv(GL_PIXEL_MAP_G_TO_G, max,
pbo_mem);
glPixelMapusv(GL_PIXEL_MAP_B_TO_B, max,
pbo_mem);
glPixelMapusv(GL_PIXEL_MAP_A_TO_A, max,
pbo_mem);
free(pbo_mem);
}
glGetIntegerv(GL_PIXEL_MAP_R_TO_R_SIZE, &size);
if (size != max) {
REPORT_FAILURE("glPixelMap failed");
return PIGLIT_FAIL;
}
glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
/* Read back pixel map */
if (use_pack) {
glGenBuffersARB(1, pb_pack);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
pb_pack[0]);
glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
max * sizeof(GLushort),
NULL, GL_STREAM_DRAW);
glGetPixelMapusv(GL_PIXEL_MAP_R_TO_R, NULL);
pbo_mem = (GLushort *) glMapBufferARB(
GL_PIXEL_PACK_BUFFER_ARB,
GL_READ_ONLY);
}
else {
pbo_mem = (GLushort *)
malloc(sizeof(GLushort) * max);
glGetPixelMapusv(GL_PIXEL_MAP_R_TO_R, pbo_mem);
}
for (i = 0; i < max; i++) {
if (pbo_mem[i] != max - i - 1) {
REPORT_FAILURE("get PixelMap failed");
return PIGLIT_FAIL;
}
}
if (use_pack) {
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
glDeleteBuffersARB(1, pb_pack);
}
else {
free(pbo_mem);
}
if (use_unpack) {
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
0);
glDeleteBuffersARB(1, pb_unpack);
}
if (!piglit_automatic)
piglit_present_results();
}
}
return PIGLIT_PASS;
}
M(void, glPixelMapusv, jint map, jint mapsize, jobject values) {
glPixelMapusv(map, mapsize, BUFF(GLushort, values));
}
