static int w32gdi_get_temperature(void){
gamma_ramp_s ramp=gamma_get_ramps(GAMMA_RAMP_SIZE);
float rb_ratio;
HDC hdc;
hdc = CreateDC(TEXT("DISPLAY"),NULL,NULL,NULL);
if( (!hdc)||(!ramp.all) ){
LOG(LOGERR,_("No device context or ramp."));
(void)DeleteDC(hdc);
return RET_FUN_FAILED;
}
if( !GetDeviceGammaRamp(hdc,ramp.all) ){
LOG(LOGERR,_("Unable to get gamma ramps."));
(void)DeleteDC(hdc);
return RET_FUN_FAILED;
}
if( (!ramp.r)||(!ramp.b) ){
LOG(LOGERR,_("No ramps found."));
(void)DeleteDC(hdc);
return RET_FUN_FAILED;
}
(void)DeleteDC(hdc);
rb_ratio = (float)ramp.r[255]/(float)ramp.b[255];
return gamma_find_temp(rb_ratio);
}
/*
** WG_GetOldGammaRamp
**
*/
void WG_GetOldGammaRamp(void)
{
HDC hDC;
hDC = GetDC(GetDesktopWindow());
GetDeviceGammaRamp(hDC, s_oldHardwareGamma);
ReleaseDC(GetDesktopWindow(), hDC);
/*
** GLimp_SetGamma
**
*/
void GLimp_SetGamma(unsigned char red[256], unsigned char green[256], unsigned char blue[256]) {
unsigned short table[3][256];
int i;
if (!glw_state.hDC) {
return;
}
for (i = 0; i < 256; i++) {
table[0][i] = (((unsigned short) red[i]) << 8) | red[i];
table[1][i] = (((unsigned short) green[i]) << 8) | green[i];
table[2][i] = (((unsigned short) blue[i]) << 8) | blue[i];
}
if (!SetDeviceGammaRamp(glw_state.hDC, table)) {
common->Printf("WARNING: SetDeviceGammaRamp failed.\n");
}
}
/*
** GLimp_UpdateGammaRamp
*/
bool GLimp_GetGammaRamp( size_t stride, unsigned short *psize, unsigned short *ramp )
{
unsigned short ramp256[3*256];
if( stride < 256 )
{
// only supports gamma ramps with 256 mappings per channel
return false;
}
if( qwglGetDeviceGammaRamp3DFX )
{
if( qwglGetDeviceGammaRamp3DFX( glw_state.hDC, ramp256 ) )
{
*psize = 256;
memcpy( ramp, ramp256, 256*sizeof(*ramp) );
memcpy( ramp+ stride, ramp256+ 256, 256*sizeof(*ramp) );
memcpy( ramp+2*stride, ramp256+2*256, 256*sizeof(*ramp) );
return true;
}
}
if( GetDeviceGammaRamp( glw_state.hDC, ramp256 ) )
{
*psize = 256;
memcpy( ramp, ramp256, 256*sizeof(*ramp) );
memcpy( ramp+ stride, ramp256+ 256, 256*sizeof(*ramp) );
memcpy( ramp+2*stride, ramp256+2*256, 256*sizeof(*ramp) );
return true;
}
return false;
}
int DIB_SetGammaRamp(_THIS, Uint16 *ramp)
{
#ifdef NO_GAMMA_SUPPORT
SDL_SetError("SDL compiled without gamma ramp support");
return -1;
#else
HDC hdc;
BOOL succeeded;
/* Set the ramp for the display */
if ( ! gamma_saved ) {
gamma_saved = (WORD *)malloc(3*256*sizeof(*gamma_saved));
if ( ! gamma_saved ) {
SDL_OutOfMemory();
return -1;
}
hdc = GetDC(SDL_Window);
GetDeviceGammaRamp(hdc, gamma_saved);
ReleaseDC(SDL_Window, hdc);
}
if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
hdc = GetDC(SDL_Window);
succeeded = SetDeviceGammaRamp(hdc, ramp);
ReleaseDC(SDL_Window, hdc);
} else {
succeeded = TRUE;
}
return succeeded ? 0 : -1;
#endif /* !NO_GAMMA_SUPPORT */
}
/*
** WG_CheckHardwareGamma
**
** Determines if the underlying hardware supports the Win32 gamma correction API.
*/
void WG_CheckHardwareGamma( void ) {
HDC hDC;
glConfig.deviceSupportsGamma = qfalse;
//BBi
//if ( qwglSetDeviceGammaRamp3DFX ) {
// glConfig.deviceSupportsGamma = qtrue;
// hDC = GetDC( GetDesktopWindow() );
// glConfig.deviceSupportsGamma = qwglGetDeviceGammaRamp3DFX( hDC, s_oldHardwareGamma );
// ReleaseDC( GetDesktopWindow(), hDC );
// return;
//}
//BBi
//BBi
//// non-3Dfx standalone drivers don't support gamma changes, period
//if ( glConfig.driverType == GLDRV_STANDALONE ) {
// return;
//}
//BBi
if ( !r_ignorehwgamma->integer ) {
hDC = GetDC( GetDesktopWindow() );
glConfig.deviceSupportsGamma = GetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
if ( glConfig.deviceSupportsGamma ) {
//
// do a sanity check on the gamma values
//
if ( ( HIBYTE( s_oldHardwareGamma[0][255] ) <= HIBYTE( s_oldHardwareGamma[0][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[1][255] ) <= HIBYTE( s_oldHardwareGamma[1][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[2][255] ) <= HIBYTE( s_oldHardwareGamma[2][0] ) ) ) {
glConfig.deviceSupportsGamma = qfalse;
ri.Printf( PRINT_WARNING, "WARNING: device has broken gamma support, generated gamma.dat\n" );
}
//
// make sure that we didn't have a prior crash in the game, and if so we need to
// restore the gamma values to at least a linear value
//
if ( ( HIBYTE( s_oldHardwareGamma[0][181] ) == 255 ) ) {
int g;
ri.Printf( PRINT_WARNING, "WARNING: suspicious gamma tables, using linear ramp for restoration\n" );
for ( g = 0; g < 255; g++ )
{
s_oldHardwareGamma[0][g] = g << 8;
s_oldHardwareGamma[1][g] = g << 8;
s_oldHardwareGamma[2][g] = g << 8;
}
}
}
}
}
void VID_BackupGamma() // jitgamma
{
HDC hdc;
hdc = GetDC (GetDesktopWindow());
gammaramp_supported = GetDeviceGammaRamp (hdc, &desktop_gammaramp[0][0]);
ReleaseDC (GetDesktopWindow(), hdc);
}
void SWimp_SaveOldHWGamma()
{
HDC desktop_hdc = GetDC( GetDesktopWindow() );
if( GetDeviceGammaRamp( desktop_hdc, old_gamma ) == FALSE )
sw_state.hw_gamma_supported= 0;
else
sw_state.hw_gamma_supported= 1;
ReleaseDC( GetDesktopWindow(), desktop_hdc );
}
/*
========================
GLimp_GetOldGammaRamp
========================
*/
static void GLimp_SaveGamma() {
HDC hDC;
BOOL success;
hDC = GetDC( GetDesktopWindow() );
success = GetDeviceGammaRamp( hDC, win32.oldHardwareGamma );
common->DPrintf( "...getting default gamma ramp: %s\n", success ? "success" : "failed" );
ReleaseDC( GetDesktopWindow(), hDC );
}
static BOOL APIENTRY GetGammaRamp (Uint16 *redtable, Uint16 *greentable, Uint16 *bluetable)
#endif
{
#ifndef unix
return GetDeviceGammaRamp(m_hDC, ramp);
#else
return (SDL_GetGammaRamp(redtable, greentable, bluetable) >= 0);
#endif
}
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetGammaRamp(IWineD3DSwapChain *iface, WINED3DGAMMARAMP *pRamp){
IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
HDC hDC;
TRACE("(%p) : pRamp@%p\n", This, pRamp);
hDC = GetDC(This->device_window);
GetDeviceGammaRamp(hDC, pRamp);
ReleaseDC(This->device_window, hDC);
return WINED3D_OK;
}
// Called from GLimp_Init()
static void ReadGamma()
{
if (r_ignorehwgamma->integer)
{
gammaStored = false;
return;
}
HWND hwnd = GetDesktopWindow();
HDC hdc = GetDC(hwnd);
gammaStored = GetDeviceGammaRamp(hdc, gammaRamp) != 0;
ReleaseDC(hwnd, hdc);
}
HRESULT CDECL wined3d_swapchain_get_gamma_ramp(const struct wined3d_swapchain *swapchain,
struct wined3d_gamma_ramp *ramp)
{
HDC dc;
TRACE("swapchain %p, ramp %p.\n", swapchain, ramp);
dc = GetDC(swapchain->device_window);
GetDeviceGammaRamp(dc, ramp);
ReleaseDC(swapchain->device_window, dc);
return WINED3D_OK;
}
/*
** GLimp_UpdateGammaRamp
*/
qboolean GLimp_GetGammaRamp( size_t stride, unsigned short *ramp )
{
if( qwglGetDeviceGammaRamp3DFX )
{
if( qwglGetDeviceGammaRamp3DFX( glw_state.hDC, ramp ) )
return qtrue;
}
if( GetDeviceGammaRamp( glw_state.hDC, ramp ) )
return qtrue;
return qfalse;
}
void _stdcall ProxyDevice::GetGammaRamp(D3DGAMMARAMP *a)
{
IDirect3DSwapChain9 *sc;
D3DPRESENT_PARAMETERS pp;
realDevice->GetSwapChain(0, &sc);
sc->GetPresentParameters(&pp);
sc->Release();
if(pp.Windowed)
GetDeviceGammaRamp(GetDC(pp.hDeviceWindow), (void*)a);
else
realDevice->GetGammaRamp(0, a);
}
void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
{
HDC dc;
WORD values[768];
dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL);
GetDeviceGammaRamp(dc, values);
DeleteDC(dc);
_glfwAllocGammaArrays(ramp, 256);
memcpy(ramp->red, values + 0, 256 * sizeof(unsigned short));
memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short));
memcpy(ramp->blue, values + 512, 256 * sizeof(unsigned short));
}
static void DIB_CheckGamma(_THIS)
{
#ifndef NO_GAMMA_SUPPORT
HDC hdc;
WORD ramp[3*256];
/* If we fail to get gamma, disable gamma control */
hdc = GetDC(SDL_Window);
if ( ! GetDeviceGammaRamp(hdc, ramp) ) {
this->GetGammaRamp = NULL;
this->SetGammaRamp = NULL;
}
ReleaseDC(SDL_Window, hdc);
#endif /* !NO_GAMMA_SUPPORT */
}
void WinWindow::getGammaRamps(WORD* ramps)
{
if (hDCChild == NULL)
return;
// see if we've got the 3Dfx gamma ramp extension
PROC proc = wglGetProcAddress("wglGetDeviceGammaRamp3DFX");
if (proc != NULL) {
GammaRamp3DFX wglGetDeviceGammaRamp3DFX = (GammaRamp3DFX)proc;
has3DFXGamma = wglGetDeviceGammaRamp3DFX(hDCChild, ramps + 3 * 256) != FALSE;
}
// get device gamma ramps
hasGamma = GetDeviceGammaRamp(hDCChild, ramps) != FALSE;
}
int DIB_GetGammaRamp(_THIS, Uint16 *ramp)
{
#ifdef NO_GAMMA_SUPPORT
SDL_SetError("SDL compiled without gamma ramp support");
return -1;
#else
HDC hdc;
BOOL succeeded;
/* Get the ramp from the display */
hdc = GetDC(SDL_Window);
succeeded = GetDeviceGammaRamp(hdc, ramp);
ReleaseDC(SDL_Window, hdc);
return succeeded ? 0 : -1;
#endif /* !NO_GAMMA_SUPPORT */
}
//--------------------------------------------------------------------------
bool VeWindows::_GetWindowGammaRamp(Window* pkWindow,
VeUInt16* pu16Ramp)
{
VideoDisplay* pkDisplay = GetDisplayForWindow(pkWindow);
VE_ASSERT(pkDisplay);
DisplayData* pkData = (DisplayData*)(VeRefObject*)(pkDisplay->m_spDriverData);
HDC hHdc;
BOOL bSucceeded = FALSE;
hHdc = CreateDC(pkData->m_acDeviceName, NULL, NULL, NULL);
if(hHdc)
{
bSucceeded = GetDeviceGammaRamp(hHdc, (LPVOID)pu16Ramp);
DeleteDC(hHdc);
}
return bSucceeded ? true : false;
}
/*
** WG_CheckHardwareGamma
**
** Determines if the underlying hardware supports the Win32 gamma correction API.
*/
void WG_CheckHardwareGamma( void )
{
HDC hDC;
glConfig.deviceSupportsGamma = qfalse;
// gamma correction
// for the fallback, always check if it will work
if ( r_gammamethod->integer >= GAMMA_HARDWARE ) {
hDC = GetDC( GetDesktopWindow() );
glConfig.deviceSupportsGamma = (qboolean)GetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
if ( glConfig.deviceSupportsGamma )
{
//
// do a sanity check on the gamma values
//
if ( ( HIBYTE( s_oldHardwareGamma[0][255] ) <= HIBYTE( s_oldHardwareGamma[0][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[1][255] ) <= HIBYTE( s_oldHardwareGamma[1][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[2][255] ) <= HIBYTE( s_oldHardwareGamma[2][0] ) ) )
{
glConfig.deviceSupportsGamma = qfalse;
ri.Printf( PRINT_WARNING, "WARNING: device has broken gamma support, generated gamma.dat\n" );
}
//
// make sure that we didn't have a prior crash in the game, and if so we need to
// restore the gamma values to at least a linear value
//
if ( ( HIBYTE( s_oldHardwareGamma[0][181] ) == 255 ) )
{
int g;
ri.Printf( PRINT_WARNING, "WARNING: suspicious gamma tables, using linear ramp for restoration\n" );
for ( g = 0; g < 255; g++ )
{
s_oldHardwareGamma[0][g] = g << 8;
s_oldHardwareGamma[1][g] = g << 8;
s_oldHardwareGamma[2][g] = g << 8;
}
}
}
}
}
/*
** WG_CheckHardwareGamma
**
** Determines if the underlying hardware supports the Win32 gamma correction API.
*/
void WG_CheckHardwareGamma( void )
{
HDC hDC;
glConfig.deviceSupportsGamma = qfalse;
if ( !r_ignorehwgamma->integer )
{
hDC = GetDC( GetDesktopWindow() );
glConfig.deviceSupportsGamma = (qboolean)GetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
if ( glConfig.deviceSupportsGamma )
{
//
// do a sanity check on the gamma values
//
if ( ( HIBYTE( s_oldHardwareGamma[0][255] ) <= HIBYTE( s_oldHardwareGamma[0][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[1][255] ) <= HIBYTE( s_oldHardwareGamma[1][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[2][255] ) <= HIBYTE( s_oldHardwareGamma[2][0] ) ) )
{
glConfig.deviceSupportsGamma = qfalse;
Com_Printf (S_COLOR_YELLOW "WARNING: device has broken gamma support, generated gamma.dat\n" );
}
//
// make sure that we didn't have a prior crash in the game, and if so we need to
// restore the gamma values to at least a linear value
//
if ( ( HIBYTE( s_oldHardwareGamma[0][181] ) == 255 ) )
{
int g;
Com_Printf (S_COLOR_YELLOW "WARNING: suspicious gamma tables, using linear ramp for restoration\n" );
for ( g = 0; g < 255; g++ )
{
s_oldHardwareGamma[0][g] = g << 8;
s_oldHardwareGamma[1][g] = g << 8;
s_oldHardwareGamma[2][g] = g << 8;
}
}
}
}
}
int
WIN_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)
{
SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
SDL_DisplayData *data = (SDL_DisplayData *) display->driverdata;
HDC hdc;
BOOL succeeded = FALSE;
hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);
if (hdc) {
succeeded = GetDeviceGammaRamp(hdc, (LPVOID)ramp);
if (!succeeded) {
WIN_SetError("GetDeviceGammaRamp()");
}
DeleteDC(hdc);
}
return succeeded ? 0 : -1;
}
void _glfwPlatformGetGammaRamp(_GLFWmonitor *monitor, GLFWgammaramp *ramp) {
HDC dc;
WORD values[768];
DISPLAY_DEVICE display;
ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
display.cb = sizeof(DISPLAY_DEVICE);
EnumDisplayDevices(monitor->win32.name, 0, &display, 0);
dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
GetDeviceGammaRamp(dc, values);
DeleteDC(dc);
_glfwAllocGammaArrays(ramp, 256);
memcpy(ramp->red, values + 0, 256 * sizeof(unsigned short));
memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short));
memcpy(ramp->blue, values + 512, 256 * sizeof(unsigned short));
}
void DIB_SwapGamma(_THIS)
{
#ifndef NO_GAMMA_SUPPORT
HDC hdc;
if ( gamma_saved ) {
hdc = GetDC(SDL_Window);
if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
/* About to leave active state, restore gamma */
SetDeviceGammaRamp(hdc, gamma_saved);
} else {
/* About to enter active state, set game gamma */
GetDeviceGammaRamp(hdc, gamma_saved);
SetDeviceGammaRamp(hdc, this->gamma);
}
ReleaseDC(SDL_Window, hdc);
}
#endif /* !NO_GAMMA_SUPPORT */
}
static int w32gdi_get_temperature(void){
gamma_ramp_s ramp=gamma_get_ramps(GAMMA_RAMP_SIZE);
float rb_ratio;
if( (!state.hDC)||(!ramp.all) ){
LOG(LOGERR,_("No device context or ramp."));
return RET_FUN_FAILED;
}
if( !GetDeviceGammaRamp(state.hDC,ramp.all) ){
LOG(LOGERR,_("Unable to get gamma ramps."));
return RET_FUN_FAILED;
}
if( (!ramp.r)||(!ramp.b) ){
LOG(LOGERR,_("No ramps found."));
return RET_FUN_FAILED;
}
rb_ratio = (float)ramp.r[255]/(float)ramp.b[255];
return gamma_find_temp(rb_ratio);
}
static int
w32gdi_start(w32gdi_state_t *state)
{
BOOL r;
/* Open device context */
HDC hDC = GetDC(NULL);
if (hDC == NULL) {
fputs(_("Unable to open device context.\n"), stderr);
return -1;
}
/* Check support for gamma ramps */
int cmcap = GetDeviceCaps(hDC, COLORMGMTCAPS);
if (cmcap != CM_GAMMA_RAMP) {
fputs(_("Display device does not support gamma ramps.\n"),
stderr);
return -1;
}
/* Allocate space for saved gamma ramps */
state->saved_ramps = malloc(3*GAMMA_RAMP_SIZE*sizeof(WORD));
if (state->saved_ramps == NULL) {
perror("malloc");
ReleaseDC(NULL, hDC);
return -1;
}
/* Save current gamma ramps so we can restore them at program exit */
r = GetDeviceGammaRamp(hDC, state->saved_ramps);
if (!r) {
fputs(_("Unable to save current gamma ramp.\n"), stderr);
ReleaseDC(NULL, hDC);
return -1;
}
/* Release device context */
ReleaseDC(NULL, hDC);
return 0;
}
int
WIN_GetDisplayGammaRamp(_THIS, Uint16 * ramp)
{
#ifdef _WIN32_WCE
return -1;
#else
SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
HDC hdc;
BOOL succeeded = FALSE;
hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);
if (hdc) {
succeeded = GetDeviceGammaRamp(hdc, ramp);
if (!succeeded) {
WIN_SetError("GetDeviceGammaRamp()");
}
DeleteDC(hdc);
}
return succeeded ? 0 : -1;
#endif
}
static int w32gdi_init(/*@unused@*/int screen_num,/*@unused@*/ int crtc_num)
{
int cmcap;
/* Open device context */
if(state.hDC)
(void)ReleaseDC(NULL, state.hDC);
state.hDC = GetDC(NULL);
if (state.hDC == NULL) {
LOG(LOGERR,_("Unable to open device context."));
return RET_FUN_FAILED;
}
/* Check support for gamma ramps */
cmcap = GetDeviceCaps(state.hDC, COLORMGMTCAPS);
if (cmcap != CM_GAMMA_RAMP) {
LOG(LOGERR,_("Display device does not support gamma ramps."));
return RET_FUN_FAILED;
}
/* Allocate space for saved gamma ramps */
if(state.saved_ramps)
free(state.saved_ramps);
state.saved_ramps = malloc(3*GAMMA_RAMP_SIZE*sizeof(WORD));
if (state.saved_ramps == NULL) {
perror("malloc");
(void)ReleaseDC(NULL, state.hDC);
return RET_FUN_FAILED;
}
/* Save current gamma ramps so we can restore them at program exit */
if( !GetDeviceGammaRamp(state.hDC, state.saved_ramps) ){
LOG(LOGERR,_("Unable to save current gamma ramp."));
(void)ReleaseDC(NULL, state.hDC);
return RET_FUN_FAILED;
}
return RET_FUN_SUCCESS;
}
/*
** VG_CheckHardwareGamma
**
** Determines if the underlying hardware supports the Win32 gamma correction API.
*/
void VG_CheckHardwareGamma( void )
{
HDC hDC;
deviceSupportsGamma = false;
hDC = GetDC( GetDesktopWindow() );
deviceSupportsGamma = GetDeviceGammaRamp( hDC, oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
if ( deviceSupportsGamma )
{
// do a sanity check on the gamma values
if ( ( HIBYTE( oldHardwareGamma[0][255] ) <= HIBYTE( oldHardwareGamma[0][0] ) ) ||
( HIBYTE( oldHardwareGamma[1][255] ) <= HIBYTE( oldHardwareGamma[1][0] ) ) ||
( HIBYTE( oldHardwareGamma[2][255] ) <= HIBYTE( oldHardwareGamma[2][0] ) ) )
{
deviceSupportsGamma = false;
ri.Con_Printf(PRINT_ALL, "Device has broken gamma support\n");
}
// make sure that we didn't have a prior crash in the game, and if so we need to
// restore the gamma values to at least a linear value
if ( ( HIBYTE( oldHardwareGamma[0][181] ) == 255 ) )
{
int g;
ri.Con_Printf(PRINT_ALL, "Suspicious gamma tables, using linear ramp for restoration\n");
for ( g = 0; g < 255; g++ )
{
oldHardwareGamma[0][g] = g << 8;
oldHardwareGamma[1][g] = g << 8;
oldHardwareGamma[2][g] = g << 8;
}
}
}
}
jobject getCurrentGammaRamp(JNIEnv *env) {
jobject gamma_buffer;
WORD *gamma;
HDC screenDC;
gamma_buffer = createNativeGammaBuffer(env);
if (gamma_buffer == NULL)
return NULL;
gamma = (WORD *)(*env)->GetDirectBufferAddress(env, gamma_buffer);
// Get the screen
screenDC = GetDC(NULL);
if (screenDC == NULL) {
throwException(env, "Couldn't get screen DC!");
return NULL;
}
// Get the default gamma ramp
if (GetDeviceGammaRamp(screenDC, gamma) == FALSE) {
printfDebugJava(env, "Failed to get initial device gamma");
}
ReleaseDC(NULL, screenDC);
return gamma_buffer;
}
