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