This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_gamma.c
236 lines (206 loc) · 6.32 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
/* Gamma correction support */
26
27
28
#include "SDL_sysvideo.h"
29
30
static void
CalculateGammaRamp(float gamma, Uint16 * ramp)
31
{
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
int i;
/* 0.0 gamma is all black */
if (gamma <= 0.0f) {
for (i = 0; i < 256; ++i) {
ramp[i] = 0;
}
return;
} else
/* 1.0 gamma is identity */
if (gamma == 1.0f) {
for (i = 0; i < 256; ++i) {
ramp[i] = (i << 8) | i;
}
return;
} else
/* Calculate a real gamma ramp */
{
int value;
gamma = 1.0f / gamma;
for (i = 0; i < 256; ++i) {
53
54
value =
(int) (SDL_pow((double) i / 256.0, gamma) * 65535.0 + 0.5);
55
56
57
58
59
60
if (value > 65535) {
value = 65535;
}
ramp[i] = (Uint16) value;
}
}
61
}
62
63
64
static void
CalculateGammaFromRamp(float *gamma, Uint16 * ramp)
65
{
66
67
68
69
70
71
72
73
74
75
76
/* The following is adapted from a post by Garrett Bass on OpenGL
Gamedev list, March 4, 2000.
*/
float sum = 0.0f;
int i, count = 0;
*gamma = 1.0;
for (i = 1; i < 256; ++i) {
if ((ramp[i] != 0) && (ramp[i] != 65535)) {
double B = (double) i / 256.0;
double A = ramp[i] / 65535.0;
77
sum += (float) (SDL_log(A) / SDL_log(B));
78
79
80
81
82
83
count++;
}
}
if (count && sum > 0.0f) {
*gamma = 1.0f / (sum / count);
}
84
85
}
86
87
int
SDL_SetGamma(float red, float green, float blue)
88
{
89
90
91
92
93
94
95
Uint16 ramp[3][256];
CalculateGammaRamp(red, ramp[0]);
CalculateGammaRamp(green, ramp[1]);
CalculateGammaRamp(blue, ramp[2]);
return SDL_SetGammaRamp(ramp[0], ramp[1], ramp[2]);
96
97
98
99
100
}
/* Calculating the gamma by integrating the gamma ramps isn't exact,
so this function isn't officially supported.
*/
101
102
int
SDL_GetGamma(float *red, float *green, float *blue)
103
{
104
105
106
107
108
109
110
111
112
113
int succeeded;
Uint16 ramp[3][256];
succeeded = SDL_GetGammaRamp(ramp[0], ramp[1], ramp[2]);
if (succeeded >= 0) {
CalculateGammaFromRamp(red, ramp[0]);
CalculateGammaFromRamp(green, ramp[1]);
CalculateGammaFromRamp(blue, ramp[2]);
}
return succeeded;
114
115
}
116
117
118
119
120
121
static void
SDL_UninitializedVideo()
{
SDL_SetError("Video subsystem has not been initialized");
}
122
int
123
SDL_SetGammaRampForDisplay(SDL_VideoDisplay * display, const Uint16 * red, const Uint16 * green, const Uint16 * blue)
124
{
125
126
127
SDL_VideoDevice *_this = SDL_GetVideoDevice();
int succeeded;
128
129
130
131
132
if (!_this) {
SDL_UninitializedVideo();
return -1;
}
133
/* Lazily allocate the gamma tables */
134
135
136
137
if (!display->gamma) {
if (SDL_GetGammaRampForDisplay(display, NULL, NULL, NULL) < 0) {
return -1;
}
138
139
140
141
}
/* Fill the gamma table with the new values */
if (red) {
142
SDL_memcpy(&display->gamma[0 * 256], red, 256 * sizeof(*display->gamma));
143
144
}
if (green) {
145
SDL_memcpy(&display->gamma[1 * 256], green, 256 * sizeof(*display->gamma));
146
147
}
if (blue) {
148
SDL_memcpy(&display->gamma[2 * 256], blue, 256 * sizeof(*display->gamma));
149
150
151
152
153
154
155
}
/* Try to set the gamma ramp in the driver */
succeeded = -1;
if (_this && _this->SetDisplayGammaRamp) {
if (SDL_GetFocusWindow()) {
succeeded =
156
_this->SetDisplayGammaRamp(_this, display, display->gamma);
157
158
159
160
161
162
163
} else {
succeeded = 0;
}
} else {
SDL_SetError("Gamma ramp manipulation not supported");
}
return succeeded;
164
165
}
166
int
167
168
169
170
171
172
173
174
175
176
177
178
SDL_SetGammaRamp(const Uint16 * red, const Uint16 * green, const Uint16 * blue)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
if (!_this) {
SDL_UninitializedVideo();
return -1;
}
return SDL_SetGammaRampForDisplay(&SDL_CurrentDisplay, red, green, blue);
}
int
SDL_GetGammaRampForDisplay(SDL_VideoDisplay * display, Uint16 * red, Uint16 * green, Uint16 * blue)
179
{
180
181
SDL_VideoDevice *_this = SDL_GetVideoDevice();
182
183
184
185
186
if (!_this) {
SDL_UninitializedVideo();
return -1;
}
187
/* Lazily allocate the gamma table */
188
189
if (!display->gamma) {
size_t rampsize = (3 * 256 * sizeof(*display->gamma));
190
191
192
display->gamma = SDL_malloc(rampsize * 2);
if (!display->gamma) {
193
194
195
196
197
SDL_OutOfMemory();
return -1;
}
if (_this && _this->GetDisplayGammaRamp) {
/* Get the real hardware gamma */
198
_this->GetDisplayGammaRamp(_this, display, display->gamma);
199
200
201
202
} else {
/* Assume an identity gamma */
int i;
for (i = 0; i < 256; ++i) {
203
204
205
display->gamma[0 * 256 + i] = (i << 8) | i;
display->gamma[1 * 256 + i] = (i << 8) | i;
display->gamma[2 * 256 + i] = (i << 8) | i;
206
207
}
}
208
209
display->saved_gamma = display->gamma + (3 * 256);
SDL_memcpy(display->saved_gamma, display->gamma, rampsize);
210
211
212
213
}
/* Just copy from our internal table */
if (red) {
214
SDL_memcpy(red, &display->gamma[0 * 256], 256 * sizeof(*red));
215
216
}
if (green) {
217
SDL_memcpy(green, &display->gamma[1 * 256], 256 * sizeof(*green));
218
219
}
if (blue) {
220
SDL_memcpy(blue, &display->gamma[2 * 256], 256 * sizeof(*blue));
221
222
}
return 0;
223
}
224
225
226
227
228
229
230
231
232
233
234
235
int
SDL_GetGammaRamp(Uint16 * red, Uint16 * green, Uint16 * blue)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
if (!_this) {
SDL_UninitializedVideo();
return -1;
}
return SDL_GetGammaRampForDisplay(&SDL_CurrentDisplay, red, green, blue);
}
236
/* vi: set ts=4 sw=4 expandtab: */