/* The standard function TIFFWriteNormalTag() could definitely be replaced
with a simple call to this function, just adding TIFFGetField() as the
last argument. */
static int
TIFFWriteNormalSubTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip,
int (*getFieldFn)(TIFF *tif, ttag_t tag, ...))
{
u_short wc = (u_short) fip->field_writecount;
dir->tdir_tag = fip->field_tag;
dir->tdir_type = (u_short) fip->field_type;
dir->tdir_count = wc;
#define WRITEF(x,y) x(tif, fip->field_type, fip->field_tag, dir, wc, y)
switch (fip->field_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
if (wc > 1) {
uint16* wp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &wp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &wp);
if (!WRITEF(TIFFWriteShortArray, wp))
return (0);
} else {
uint16 sv;
(*getFieldFn)(tif, fip->field_tag, &sv);
dir->tdir_offset =
TIFFInsertData(tif, dir->tdir_type, sv);
}
break;
case TIFF_LONG:
case TIFF_SLONG:
if (wc > 1) {
uint32* lp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &lp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &lp);
if (!WRITEF(TIFFWriteLongArray, lp))
return (0);
} else {
/* XXX handle LONG->SHORT conversion */
(*getFieldFn)(tif, fip->field_tag, &dir->tdir_offset);
}
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
if (wc > 1) {
float* fp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &fp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &fp);
if (!WRITEF(TIFFWriteRationalArray, fp))
return (0);
} else {
float fv;
(*getFieldFn)(tif, fip->field_tag, &fv);
if (!WRITEF(TIFFWriteRationalArray, &fv))
return (0);
}
break;
case TIFF_FLOAT:
if (wc > 1) {
float* fp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &fp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &fp);
if (!WRITEF(TIFFWriteFloatArray, fp))
return (0);
} else {
float fv;
(*getFieldFn)(tif, fip->field_tag, &fv);
if (!WRITEF(TIFFWriteFloatArray, &fv))
return (0);
}
break;
case TIFF_DOUBLE:
/* Hey - I think this is a bug, or at least a "gross
inconsistency", in the TIFF library. Look at the original
TIFF library code below within the "#if (0) ... #else".
Just from the type of *dp, you can see that this code
expects TIFFGetField() to be handed a double ** for
any TIFF_DOUBLE tag, even for the constant wc==1 case.
This is totally inconsistent with other fields (like
TIFF_FLOAT, above) and is also inconsistent with the
TIFFSetField() function for TIFF_DOUBLEs, which expects
to be passed a single double by value for the wc==1 case.
(See the handling of TIFFFetchNormalTag() in tif_dirread.c
for an example.) Maybe this function was written before
TIFFWriteDoubleArray() was written, not that that's an
excuse. Anyway, the new code below is a trivial modification
of the TIFF_FLOAT code above. The fact that even single
doubles get written out in the data segment and get an
offset value stored is irrelevant here - that is all
handled by TIFFWriteDoubleArray(). */
#if (0)
{ double* dp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &dp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &dp);
TIFFCvtNativeToIEEEDouble(tif, wc, dp);
if (!TIFFWriteData(tif, dir, (char*) dp))
return (0);
}
#else
if (wc > 1) {
double* dp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &dp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &dp);
if (!WRITEF(TIFFWriteDoubleArray, dp))
return (0);
} else {
double dv;
(*getFieldFn)(tif, fip->field_tag, &dv);
if (!WRITEF(TIFFWriteDoubleArray, &dv))
return (0);
}
#endif
break;
case TIFF_ASCII:
{ char* cp;
(*getFieldFn)(tif, fip->field_tag, &cp);
dir->tdir_count = (uint32) (strlen(cp) + 1);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
}
break;
case TIFF_UNDEFINED:
{ char* cp;
if (wc == (u_short) TIFF_VARIABLE) {
(*getFieldFn)(tif, fip->field_tag, &wc, &cp);
dir->tdir_count = wc;
} else
(*getFieldFn)(tif, fip->field_tag, &cp);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
}
break;
}
return (1);
}
/*
* Process tags that are not special cased.
*/
static int
TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)
{
u_short wc = (u_short) fip->field_writecount;
uint32 wc2;
dir->tdir_tag = (uint16) fip->field_tag;
dir->tdir_type = (u_short) fip->field_type;
dir->tdir_count = wc;
#define WRITEF(x,y) x(tif, fip->field_type, fip->field_tag, dir, wc, y)
switch (fip->field_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
if (wc > 1) {
uint16* wp;
if (wc == (u_short) TIFF_VARIABLE)
TIFFGetField(tif, fip->field_tag, &wc, &wp);
else
TIFFGetField(tif, fip->field_tag, &wp);
if (!WRITEF(TIFFWriteShortArray, wp))
return (0);
} else {
uint16 sv;
TIFFGetField(tif, fip->field_tag, &sv);
dir->tdir_offset =
TIFFInsertData(tif, dir->tdir_type, sv);
}
break;
case TIFF_LONG:
case TIFF_SLONG:
if (wc > 1) {
uint32* lp;
if (wc == (u_short) TIFF_VARIABLE)
TIFFGetField(tif, fip->field_tag, &wc, &lp);
else
TIFFGetField(tif, fip->field_tag, &lp);
if (!WRITEF(TIFFWriteLongArray, lp))
return (0);
} else {
/* XXX handle LONG->SHORT conversion */
TIFFGetField(tif, fip->field_tag, &dir->tdir_offset);
}
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
if (wc > 1) {
float* fp;
if (wc == (u_short) TIFF_VARIABLE)
TIFFGetField(tif, fip->field_tag, &wc, &fp);
else
TIFFGetField(tif, fip->field_tag, &fp);
if (!WRITEF(TIFFWriteRationalArray, fp))
return (0);
} else {
float fv;
TIFFGetField(tif, fip->field_tag, &fv);
if (!WRITEF(TIFFWriteRationalArray, &fv))
return (0);
}
break;
case TIFF_FLOAT:
if (wc > 1) {
float* fp;
if (wc == (u_short) TIFF_VARIABLE)
TIFFGetField(tif, fip->field_tag, &wc, &fp);
else
TIFFGetField(tif, fip->field_tag, &fp);
if (!WRITEF(TIFFWriteFloatArray, fp))
return (0);
} else {
float fv;
TIFFGetField(tif, fip->field_tag, &fv);
if (!WRITEF(TIFFWriteFloatArray, &fv))
return (0);
}
break;
case TIFF_DOUBLE:
if (wc > 1) {
double* dp;
if (wc == (u_short) TIFF_VARIABLE)
TIFFGetField(tif, fip->field_tag, &wc, &dp);
else
TIFFGetField(tif, fip->field_tag, &dp);
if (!WRITEF(TIFFWriteDoubleArray, dp))
return (0);
} else {
double dv;
TIFFGetField(tif, fip->field_tag, &dv);
if (!WRITEF(TIFFWriteDoubleArray, &dv))
return (0);
}
break;
case TIFF_ASCII:
{ char* cp;
TIFFGetField(tif, fip->field_tag, &cp);
dir->tdir_count = (uint32) (strlen(cp) + 1);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
}
break;
/* added based on patch request from [email protected],
correctness not verified (FW, 99/08) */
case TIFF_BYTE:
case TIFF_SBYTE:
if (wc > 1) {
char* cp;
if (wc == (u_short) TIFF_VARIABLE) {
TIFFGetField(tif, fip->field_tag, &wc, &cp);
dir->tdir_count = wc;
} else if (wc == (u_short) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &cp);
dir->tdir_count = wc2;
} else
TIFFGetField(tif, fip->field_tag, &cp);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
} else {
char cv;
TIFFGetField(tif, fip->field_tag, &cv);
if (!TIFFWriteByteArray(tif, dir, &cv))
return (0);
}
break;
case TIFF_UNDEFINED:
{ char* cp;
if (wc == (u_short) TIFF_VARIABLE) {
TIFFGetField(tif, fip->field_tag, &wc, &cp);
dir->tdir_count = wc;
} else if (wc == (u_short) TIFF_VARIABLE2) {
TIFFGetField(tif, fip->field_tag, &wc2, &cp);
dir->tdir_count = wc2;
} else
TIFFGetField(tif, fip->field_tag, &cp);
if (!TIFFWriteByteArray(tif, dir, cp))
return (0);
}
break;
case TIFF_NOTYPE:
break;
}
return (1);
}
static void gammaDDLightfv(GLcontext *ctx, GLenum light, GLenum pname,
const GLfloat *params, GLint nParams)
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
GLfloat l,x,y,z,w;
switch(light) {
case GL_LIGHT0:
switch (pname) {
case GL_AMBIENT:
CHECK_DMA_BUFFER(gmesa, 3);
/* We don't do alpha */
WRITEF(gmesa->buf, Light0AmbientIntensityBlue, params[2]);
WRITEF(gmesa->buf, Light0AmbientIntensityGreen, params[1]);
WRITEF(gmesa->buf, Light0AmbientIntensityRed, params[0]);
break;
case GL_DIFFUSE:
CHECK_DMA_BUFFER(gmesa, 3);
/* We don't do alpha */
WRITEF(gmesa->buf, Light0DiffuseIntensityBlue, params[2]);
WRITEF(gmesa->buf, Light0DiffuseIntensityGreen, params[1]);
WRITEF(gmesa->buf, Light0DiffuseIntensityRed, params[0]);
break;
case GL_SPECULAR:
CHECK_DMA_BUFFER(gmesa, 3);
/* We don't do alpha */
WRITEF(gmesa->buf, Light0SpecularIntensityBlue, params[2]);
WRITEF(gmesa->buf, Light0SpecularIntensityGreen, params[1]);
WRITEF(gmesa->buf, Light0SpecularIntensityRed, params[0]);
break;
case GL_POSITION:
/* Normalize <x,y,z> */
x = params[0]; y = params[1]; z = params[2]; w = params[3];
l = sqrt(x*x + y*y + z*z + w*w);
w /= l;
x /= l;
y /= l;
z /= l;
if (params[3] != 0.0) {
gmesa->Light0Mode |= Light0ModeAttenuation;
gmesa->Light0Mode |= Light0ModeLocal;
} else {
gmesa->Light0Mode &= ~Light0ModeAttenuation;
gmesa->Light0Mode &= ~Light0ModeLocal;
}
CHECK_DMA_BUFFER(gmesa, 5);
WRITE(gmesa->buf, Light0Mode, gmesa->Light0Mode);
WRITEF(gmesa->buf, Light0PositionW, w);
WRITEF(gmesa->buf, Light0PositionZ, z);
WRITEF(gmesa->buf, Light0PositionY, y);
WRITEF(gmesa->buf, Light0PositionX, x);
break;
case GL_SPOT_DIRECTION:
CHECK_DMA_BUFFER(gmesa, 3);
/* WRITEF(gmesa->buf, Light0SpotlightDirectionW, params[3]); */
WRITEF(gmesa->buf, Light0SpotlightDirectionZ, params[2]);
WRITEF(gmesa->buf, Light0SpotlightDirectionY, params[1]);
WRITEF(gmesa->buf, Light0SpotlightDirectionX, params[0]);
break;
case GL_SPOT_EXPONENT:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0SpotlightExponent, params[0]);
break;
case GL_SPOT_CUTOFF:
if (params[0] != 180.0)
gmesa->Light0Mode |= Light0ModeSpotLight;
else
gmesa->Light0Mode &= ~Light0ModeSpotLight;
CHECK_DMA_BUFFER(gmesa, 2);
WRITE(gmesa->buf, Light0Mode, gmesa->Light0Mode);
WRITEF(gmesa->buf, Light0CosSpotlightCutoffAngle, cos(params[0]*DEG2RAD));
break;
case GL_CONSTANT_ATTENUATION:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0ConstantAttenuation, params[0]);
break;
case GL_LINEAR_ATTENUATION:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0LinearAttenuation, params[0]);
break;
case GL_QUADRATIC_ATTENUATION:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0QuadraticAttenuation, params[0]);
break;
}
break;
}
}
/*
* Load the current context's state into the hardware.
*
* NOTE: Be VERY careful about ensuring the context state is marked for
* upload, the only place it shouldn't be uploaded is when the setup
* state has changed in ReducedPrimitiveChange as this comes right after
* a state update.
*
* Blits of any type should always upload the context and masks after
* they are done.
*/
void gammaEmitHwState( gammaContextPtr gmesa )
{
if (!gmesa->driDrawable) return;
if (!gmesa->dirty) return;
#ifdef DO_VALIDATE
/* Flush any partially filled buffers */
FLUSH_DMA_BUFFER(gmesa);
DRM_SPINLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
gmesa->driScreen->drawLockID);
VALIDATE_DRAWABLE_INFO_NO_LOCK(gmesa);
#endif
if (gmesa->dirty & GAMMA_UPLOAD_VIEWPORT) {
gmesa->dirty &= ~GAMMA_UPLOAD_VIEWPORT;
CHECK_DMA_BUFFER(gmesa, 6);
WRITEF(gmesa->buf, ViewPortOffsetX, gmesa->ViewportOffsetX);
WRITEF(gmesa->buf, ViewPortOffsetY, gmesa->ViewportOffsetY);
WRITEF(gmesa->buf, ViewPortOffsetZ, gmesa->ViewportOffsetZ);
WRITEF(gmesa->buf, ViewPortScaleX, gmesa->ViewportScaleX);
WRITEF(gmesa->buf, ViewPortScaleY, gmesa->ViewportScaleY);
WRITEF(gmesa->buf, ViewPortScaleZ, gmesa->ViewportScaleZ);
}
if ( (gmesa->dirty & GAMMA_UPLOAD_POINTMODE) ||
(gmesa->dirty & GAMMA_UPLOAD_LINEMODE) ||
(gmesa->dirty & GAMMA_UPLOAD_TRIMODE) ) {
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, AntialiasMode, gmesa->AntialiasMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_POINTMODE) {
gmesa->dirty &= ~GAMMA_UPLOAD_POINTMODE;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, PointMode, gmesa->PointMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_LINEMODE) {
gmesa->dirty &= ~GAMMA_UPLOAD_LINEMODE;
CHECK_DMA_BUFFER(gmesa, 2);
WRITE(gmesa->buf, LineMode, gmesa->LineMode);
WRITE(gmesa->buf, LineStippleMode, gmesa->LineMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_TRIMODE) {
gmesa->dirty &= ~GAMMA_UPLOAD_TRIMODE;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, TriangleMode, gmesa->TriangleMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_FOG) {
GLchan c[3], col;
UNCLAMPED_FLOAT_TO_RGB_CHAN( c, gmesa->glCtx->Fog.Color );
col = gammaPackColor(4, c[0], c[1], c[2], 0);
gmesa->dirty &= ~GAMMA_UPLOAD_FOG;
CHECK_DMA_BUFFER(gmesa, 5);
#if 0
WRITE(gmesa->buf, FogMode, gmesa->FogMode);
WRITE(gmesa->buf, FogColor, col);
WRITEF(gmesa->buf, FStart, gmesa->glCtx->Fog.Start);
#endif
WRITEF(gmesa->buf, FogEnd, gmesa->glCtx->Fog.End);
WRITEF(gmesa->buf, FogDensity, gmesa->glCtx->Fog.Density);
WRITEF(gmesa->buf, FogScale,
1.0f/(gmesa->glCtx->Fog.End - gmesa->glCtx->Fog.Start));
}
if (gmesa->dirty & GAMMA_UPLOAD_DITHER) {
gmesa->dirty &= ~GAMMA_UPLOAD_DITHER;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, DitherMode, gmesa->DitherMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_LOGICOP) {
gmesa->dirty &= ~GAMMA_UPLOAD_LOGICOP;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, LogicalOpMode, gmesa->LogicalOpMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_CLIP) {
gmesa->dirty &= ~GAMMA_UPLOAD_CLIP;
CHECK_DMA_BUFFER(gmesa, 3);
WRITE(gmesa->buf, ScissorMinXY, gmesa->ScissorMinXY);
WRITE(gmesa->buf, ScissorMaxXY, gmesa->ScissorMaxXY);
WRITE(gmesa->buf, ScissorMode, gmesa->ScissorMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_MASKS) {
gmesa->dirty &= ~GAMMA_UPLOAD_MASKS;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, FBHardwareWriteMask, gmesa->FBHardwareWriteMask);
}
if (gmesa->dirty & GAMMA_UPLOAD_ALPHA) {
gmesa->dirty &= ~GAMMA_UPLOAD_ALPHA;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, AlphaTestMode, gmesa->AlphaTestMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_BLEND) {
gmesa->dirty &= ~GAMMA_UPLOAD_BLEND;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, AlphaBlendMode, gmesa->AlphaBlendMode);
}
CHECK_DMA_BUFFER(gmesa, 1);
if (gmesa->glCtx->Color.BlendEnabled || gmesa->glCtx->Color.AlphaEnabled) {
WRITE(gmesa->buf, FBReadMode, gmesa->FBReadMode | gmesa->AB_FBReadMode_Save);
} else {
WRITE(gmesa->buf, FBReadMode, gmesa->FBReadMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_LIGHT) {
gmesa->dirty &= ~GAMMA_UPLOAD_LIGHT;
CHECK_DMA_BUFFER(gmesa, 2);
WRITE(gmesa->buf, LightingMode, gmesa->LightingMode);
WRITE(gmesa->buf, MaterialMode, gmesa->MaterialMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_SHADE) {
gmesa->dirty &= ~GAMMA_UPLOAD_SHADE;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, ColorDDAMode, gmesa->ColorDDAMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_POLYGON) {
gmesa->dirty &= ~GAMMA_UPLOAD_POLYGON;
CHECK_DMA_BUFFER(gmesa, 2);
WRITEF(gmesa->buf, PolygonOffsetBias, gmesa->glCtx->Polygon.OffsetUnits);
WRITEF(gmesa->buf, PolygonOffsetFactor, gmesa->glCtx->Polygon.OffsetFactor);
}
if (gmesa->dirty & GAMMA_UPLOAD_STIPPLE) {
gmesa->dirty &= ~GAMMA_UPLOAD_STIPPLE;
CHECK_DMA_BUFFER(gmesa, 33);
WRITE(gmesa->buf, AreaStippleMode, gmesa->AreaStippleMode);
WRITE(gmesa->buf, AreaStipplePattern0, gmesa->glCtx->PolygonStipple[0]);
WRITE(gmesa->buf, AreaStipplePattern1, gmesa->glCtx->PolygonStipple[1]);
WRITE(gmesa->buf, AreaStipplePattern2, gmesa->glCtx->PolygonStipple[2]);
WRITE(gmesa->buf, AreaStipplePattern3, gmesa->glCtx->PolygonStipple[3]);
WRITE(gmesa->buf, AreaStipplePattern4, gmesa->glCtx->PolygonStipple[4]);
WRITE(gmesa->buf, AreaStipplePattern5, gmesa->glCtx->PolygonStipple[5]);
WRITE(gmesa->buf, AreaStipplePattern6, gmesa->glCtx->PolygonStipple[6]);
WRITE(gmesa->buf, AreaStipplePattern7, gmesa->glCtx->PolygonStipple[7]);
WRITE(gmesa->buf, AreaStipplePattern8, gmesa->glCtx->PolygonStipple[8]);
WRITE(gmesa->buf, AreaStipplePattern9, gmesa->glCtx->PolygonStipple[9]);
WRITE(gmesa->buf, AreaStipplePattern10, gmesa->glCtx->PolygonStipple[10]);
WRITE(gmesa->buf, AreaStipplePattern11, gmesa->glCtx->PolygonStipple[11]);
WRITE(gmesa->buf, AreaStipplePattern12, gmesa->glCtx->PolygonStipple[12]);
WRITE(gmesa->buf, AreaStipplePattern13, gmesa->glCtx->PolygonStipple[13]);
WRITE(gmesa->buf, AreaStipplePattern14, gmesa->glCtx->PolygonStipple[14]);
WRITE(gmesa->buf, AreaStipplePattern15, gmesa->glCtx->PolygonStipple[15]);
WRITE(gmesa->buf, AreaStipplePattern16, gmesa->glCtx->PolygonStipple[16]);
WRITE(gmesa->buf, AreaStipplePattern17, gmesa->glCtx->PolygonStipple[17]);
WRITE(gmesa->buf, AreaStipplePattern18, gmesa->glCtx->PolygonStipple[18]);
WRITE(gmesa->buf, AreaStipplePattern19, gmesa->glCtx->PolygonStipple[19]);
WRITE(gmesa->buf, AreaStipplePattern20, gmesa->glCtx->PolygonStipple[20]);
WRITE(gmesa->buf, AreaStipplePattern21, gmesa->glCtx->PolygonStipple[21]);
WRITE(gmesa->buf, AreaStipplePattern22, gmesa->glCtx->PolygonStipple[22]);
WRITE(gmesa->buf, AreaStipplePattern23, gmesa->glCtx->PolygonStipple[23]);
WRITE(gmesa->buf, AreaStipplePattern24, gmesa->glCtx->PolygonStipple[24]);
WRITE(gmesa->buf, AreaStipplePattern25, gmesa->glCtx->PolygonStipple[25]);
WRITE(gmesa->buf, AreaStipplePattern26, gmesa->glCtx->PolygonStipple[26]);
WRITE(gmesa->buf, AreaStipplePattern27, gmesa->glCtx->PolygonStipple[27]);
WRITE(gmesa->buf, AreaStipplePattern28, gmesa->glCtx->PolygonStipple[28]);
WRITE(gmesa->buf, AreaStipplePattern29, gmesa->glCtx->PolygonStipple[29]);
WRITE(gmesa->buf, AreaStipplePattern30, gmesa->glCtx->PolygonStipple[30]);
WRITE(gmesa->buf, AreaStipplePattern31, gmesa->glCtx->PolygonStipple[31]);
}
if (gmesa->dirty & GAMMA_UPLOAD_DEPTH) {
gmesa->dirty &= ~GAMMA_UPLOAD_DEPTH;
CHECK_DMA_BUFFER(gmesa, 4);
WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
WRITE(gmesa->buf, GLINTWindow,gmesa->Window | (gmesa->FrameCount << 9));
WRITE(gmesa->buf, LBReadMode, gmesa->LBReadMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_GEOMETRY) {
gmesa->dirty &= ~GAMMA_UPLOAD_GEOMETRY;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, GeometryMode, gmesa->GeometryMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_TRANSFORM) {
gmesa->dirty &= ~GAMMA_UPLOAD_TRANSFORM;
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, TransformMode, gmesa->TransformMode);
}
if (gmesa->dirty & GAMMA_UPLOAD_TEX0) {
gammaTextureObjectPtr curTex = gmesa->CurrentTexObj[0];
gmesa->dirty &= ~GAMMA_UPLOAD_TEX0;
if (curTex) {
CHECK_DMA_BUFFER(gmesa, 21);
WRITE(gmesa->buf, GeometryMode, gmesa->GeometryMode | GM_TextureEnable);
WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode | DM_TextureEnable);
WRITE(gmesa->buf, TextureAddressMode, curTex->TextureAddressMode);
WRITE(gmesa->buf, TextureReadMode, curTex->TextureReadMode);
WRITE(gmesa->buf, TextureColorMode, curTex->TextureColorMode);
WRITE(gmesa->buf, TextureFilterMode, curTex->TextureFilterMode);
WRITE(gmesa->buf, TextureFormat, curTex->TextureFormat);
WRITE(gmesa->buf, GLINTBorderColor, curTex->TextureBorderColor);
WRITE(gmesa->buf, TxBaseAddr0, curTex->TextureBaseAddr[0]);
WRITE(gmesa->buf, TxBaseAddr1, curTex->TextureBaseAddr[1]);
WRITE(gmesa->buf, TxBaseAddr2, curTex->TextureBaseAddr[2]);
WRITE(gmesa->buf, TxBaseAddr3, curTex->TextureBaseAddr[3]);
WRITE(gmesa->buf, TxBaseAddr4, curTex->TextureBaseAddr[4]);
WRITE(gmesa->buf, TxBaseAddr5, curTex->TextureBaseAddr[5]);
WRITE(gmesa->buf, TxBaseAddr6, curTex->TextureBaseAddr[6]);
WRITE(gmesa->buf, TxBaseAddr7, curTex->TextureBaseAddr[7]);
WRITE(gmesa->buf, TxBaseAddr8, curTex->TextureBaseAddr[8]);
WRITE(gmesa->buf, TxBaseAddr9, curTex->TextureBaseAddr[9]);
WRITE(gmesa->buf, TxBaseAddr10, curTex->TextureBaseAddr[10]);
WRITE(gmesa->buf, TxBaseAddr11, curTex->TextureBaseAddr[11]);
WRITE(gmesa->buf, TextureCacheControl, (TCC_Enable | TCC_Invalidate));
} else {
CHECK_DMA_BUFFER(gmesa, 6);
WRITE(gmesa->buf, GeometryMode, gmesa->GeometryMode);
WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
WRITE(gmesa->buf, TextureAddressMode, TextureAddressModeDisable);
WRITE(gmesa->buf, TextureReadMode, TextureReadModeDisable);
WRITE(gmesa->buf, TextureFilterMode, TextureFilterModeDisable);
WRITE(gmesa->buf, TextureColorMode, TextureColorModeDisable);
}
}
#ifdef DO_VALIDATE
PROCESS_DMA_BUFFER_TOP_HALF(gmesa);
DRM_SPINUNLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
gmesa->driScreen->drawLockID);
VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gmesa);
PROCESS_DMA_BUFFER_BOTTOM_HALF(gmesa);
#endif
}
static void gammaLoadHWMatrix(GLcontext *ctx)
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
const GLfloat *m;
gmesa->TransformMode &= ~XM_XformTexture;
switch (ctx->Transform.MatrixMode) {
case GL_MODELVIEW:
gmesa->TransformMode |= XM_UseModelViewMatrix;
m = ctx->ModelviewMatrixStack.Top->m;
CHECK_DMA_BUFFER(gmesa, 16);
WRITEF(gmesa->buf, ModelViewMatrix0, m[0]);
WRITEF(gmesa->buf, ModelViewMatrix1, m[1]);
WRITEF(gmesa->buf, ModelViewMatrix2, m[2]);
WRITEF(gmesa->buf, ModelViewMatrix3, m[3]);
WRITEF(gmesa->buf, ModelViewMatrix4, m[4]);
WRITEF(gmesa->buf, ModelViewMatrix5, m[5]);
WRITEF(gmesa->buf, ModelViewMatrix6, m[6]);
WRITEF(gmesa->buf, ModelViewMatrix7, m[7]);
WRITEF(gmesa->buf, ModelViewMatrix8, m[8]);
WRITEF(gmesa->buf, ModelViewMatrix9, m[9]);
WRITEF(gmesa->buf, ModelViewMatrix10, m[10]);
WRITEF(gmesa->buf, ModelViewMatrix11, m[11]);
WRITEF(gmesa->buf, ModelViewMatrix12, m[12]);
WRITEF(gmesa->buf, ModelViewMatrix13, m[13]);
WRITEF(gmesa->buf, ModelViewMatrix14, m[14]);
WRITEF(gmesa->buf, ModelViewMatrix15, m[15]);
break;
case GL_PROJECTION:
m = ctx->ProjectionMatrixStack.Top->m;
CHECK_DMA_BUFFER(gmesa, 16);
WRITEF(gmesa->buf, ModelViewProjectionMatrix0, m[0]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix1, m[1]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix2, m[2]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix3, m[3]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix4, m[4]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix5, m[5]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix6, m[6]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix7, m[7]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix8, m[8]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix9, m[9]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix10, m[10]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix11, m[11]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix12, m[12]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix13, m[13]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix14, m[14]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix15, m[15]);
break;
case GL_TEXTURE:
m = ctx->TextureMatrixStack[0].Top->m;
CHECK_DMA_BUFFER(gmesa, 16);
gmesa->TransformMode |= XM_XformTexture;
WRITEF(gmesa->buf, TextureMatrix0, m[0]);
WRITEF(gmesa->buf, TextureMatrix1, m[1]);
WRITEF(gmesa->buf, TextureMatrix2, m[2]);
WRITEF(gmesa->buf, TextureMatrix3, m[3]);
WRITEF(gmesa->buf, TextureMatrix4, m[4]);
WRITEF(gmesa->buf, TextureMatrix5, m[5]);
WRITEF(gmesa->buf, TextureMatrix6, m[6]);
WRITEF(gmesa->buf, TextureMatrix7, m[7]);
WRITEF(gmesa->buf, TextureMatrix8, m[8]);
WRITEF(gmesa->buf, TextureMatrix9, m[9]);
WRITEF(gmesa->buf, TextureMatrix10, m[10]);
WRITEF(gmesa->buf, TextureMatrix11, m[11]);
WRITEF(gmesa->buf, TextureMatrix12, m[12]);
WRITEF(gmesa->buf, TextureMatrix13, m[13]);
WRITEF(gmesa->buf, TextureMatrix14, m[14]);
WRITEF(gmesa->buf, TextureMatrix15, m[15]);
break;
default:
/* ERROR!!! -- how did this happen? */
break;
}
gmesa->dirty |= GAMMA_UPLOAD_TRANSFORM;
}
VOID
Client(
char* Server,
char* Pipe
)
{
HANDLE *Connection;
DWORD tid;
MyStdInp=GetStdHandle(STD_INPUT_HANDLE);
MyStdOut=GetStdHandle(STD_OUTPUT_HANDLE);
WRITEF((VBuff,"**************************************\n"));
WRITEF((VBuff,"*********** REMOTE ************\n"));
WRITEF((VBuff,"*********** CLIENT ************\n"));
WRITEF((VBuff,"**************************************\n"));
if ((Connection=EstablishSession(Server,Pipe))==NULL)
return;
ReadPipe=Connection[0];
WritePipe=Connection[1];
SetConsoleCtrlHandler((PHANDLER_ROUTINE)Mych,TRUE);
// Start Thread For Server --> Client Flow
if ((iothreads[0]=CreateThread((LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
(DWORD)0, // Use same stack size.
(LPTHREAD_START_ROUTINE)GetServerOut, // Thread procedure.
(LPVOID)NULL, // Parameter to pass.
(DWORD)0, // Run immediately.
(LPDWORD)&tid))==NULL) // Thread identifier.
{
Errormsg("Could Not Create rwSrv2Cl Thread");
return;
}
//
// Start Thread for Client --> Server Flow
//
if ((iothreads[1]=CreateThread((LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
(DWORD)0, // Use same stack size.
(LPTHREAD_START_ROUTINE)SendServerInp, // Thread procedure.
(LPVOID)NULL, // Parameter to pass.
(DWORD)0, // Run immediately.
(LPDWORD)&tid))==NULL) // Thread identifier.
{
Errormsg("Could Not Create rwSrv2Cl Thread");
return;
}
WaitForMultipleObjects(2,iothreads,FALSE,INFINITE);
TerminateThread(iothreads[0],1);
TerminateThread(iothreads[1],1);
WRITEF((VBuff,"*** SESSION OVER ***\n"));
}
VOID
SendMyInfo(
PHANDLE pipeH
)
{
HANDLE rPipe=pipeH[0];
HANDLE wPipe=pipeH[1];
DWORD hostlen=HOSTNAMELEN-1;
WORD BytesToSend=sizeof(SESSION_STARTUPINFO);
DWORD tmp;
SESSION_STARTUPINFO ssi;
SESSION_STARTREPLY ssr;
DWORD BytesToRead;
char *buff;
ssi.Size=BytesToSend;
ssi.Version=VERSION;
GetComputerName((char *)ssi.ClientName,&hostlen);
ssi.LinesToSend=LinesToSend;
ssi.Flag=ClientToServerFlag;
{
DWORD NewCode=MAGICNUMBER;
char Name[15];
strcpy(Name,(char *)ssi.ClientName);
memcpy(&Name[11],(char *)&NewCode,sizeof(NewCode));
WriteFile(wPipe,(char *)Name,HOSTNAMELEN-1,&tmp,NULL);
ReadFile(rPipe ,(char *)&ssr.MagicNumber,sizeof(ssr.MagicNumber),&tmp,NULL);
if (ssr.MagicNumber!=MAGICNUMBER)
{
WRITEF((VBuff,"WARNING-YOU ARE CONNECTED TO AN OLD REMOTE SERVER\n"));
WriteFile(MyStdOut,(char *)&ssr.MagicNumber,sizeof(ssr.MagicNumber),&tmp,NULL);
return;
}
//Get Rest of the info-its not the old server
ReadFixBytes(rPipe,(char *)&ssr.Size,sizeof(ssr.Size),0);
ReadFixBytes(rPipe,(char *)&ssr.FileSize,sizeof(ssr)-sizeof(ssr.FileSize)-sizeof(ssr.MagicNumber),0);
}
if (!WriteFile(wPipe,(char *)&ssi,BytesToSend,&tmp,NULL))
{
Errormsg("INFO Send Error");
return;
}
BytesToRead=MINIMUM(ssr.FileSize,ssi.LinesToSend*CHARS_PER_LINE);
buff=calloc(BytesToRead+1,1);
if (buff!=NULL)
{
DWORD bytesread=0;
ReadFile(rPipe,buff,BytesToRead,&bytesread,NULL);
WriteFile(MyStdOut,buff,bytesread,&tmp,NULL);
free(buff);
}
}
