Mercurial > sdl-ios-xcode
annotate src/video/SDL_gamma.c @ 3978:b966761fef6c SDL-1.2
Significantly improved XIM support.
Fixes Bugzilla #429.
Selected notes from the patch's README:
= FIXES =
This patch fixes the above issues as follows.
== X11 events ==
Moved XFilterEvent just after XNextEvent so that all events are passed
to it. Also, XFilterEvent will receive masks indicated by IM through
XNFilterEvents IC value as well as masks surpplied by SDL.
X11_KeyRepeat is called between XNextEvent and XFilterEvent, after
testing an event is a KeyRelease. I'm not 100% comfortable to do so,
but I couldn't find a better timing to call it, and use of the
function is inevitable.
== Xutf8LookupString ==
Used a longer buffer to receive UTF-8 string. If it is insufficient,
a dynamic storage of the requested size will be allocated. The
initial size of the buffer is set to 32, because the Japanese text
converted from the most widely used benchmark key sequence for
Japanese IM, "WATASHINONAMAEHANAKANODESU." has ten Japanese characters
in it, that occupies 30 bytes when encoded in UTF-8.
== SDL_keysym.unicode ==
On Windows version of SDL implementation, SDL_keysym.unicode stores
UTF-16 encoded unicode characters, one UTF-16 encoding unit per an SDL
event. A Unicode supplementary characters are sent to an application
as two events. (One with a high surrogate and another with a low
surrogate.) The behavior seems reasonable since it is upward
compatible with existing handling of BMP characters.
I wrote a UTF-8 to UTF-16 conversion function for the purpose. It is
designed with the execution speed in mind, having a minimum set of
features that my patch requires.
| author | Ryan C. Gordon <icculus@icculus.org> |
|---|---|
| date | Mon, 25 Jun 2007 19:58:32 +0000 |
| parents | 65800e7f7146 |
| children | c121d94672cb a1b03ba2fcd0 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
3 Copyright (C) 1997-2006 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 9 |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 18 |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
152
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
22 #include "SDL_config.h" |
| 0 | 23 |
| 24 /* Gamma correction support */ | |
| 25 | |
|
1330
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
26 #ifdef HAVE_MATH_H |
|
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
27 #include <math.h> /* Used for calculating gamma ramps */ |
|
1334
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
28 #else |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
29 /* Math routines from uClibc: http://www.uclibc.org */ |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
30 #include "math_private.h" |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
31 #include "e_sqrt.h" |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
32 #include "e_pow.h" |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
33 #include "e_log.h" |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
34 #define pow(x, y) __ieee754_pow(x, y) |
|
37d43bd654d7
Proper credit to uClibc :)
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
35 #define log(x) __ieee754_log(x) |
| 0 | 36 #endif |
| 37 | |
| 38 #include "SDL_sysvideo.h" | |
| 39 | |
|
1330
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
40 |
| 0 | 41 static void CalculateGammaRamp(float gamma, Uint16 *ramp) |
| 42 { | |
| 43 int i; | |
| 44 | |
| 45 /* 0.0 gamma is all black */ | |
|
1612
97d0966f4bf7
Fixed some ultra-pedantic gcc warnings
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
46 if ( gamma <= 0.0f ) { |
| 0 | 47 for ( i=0; i<256; ++i ) { |
| 48 ramp[i] = 0; | |
| 49 } | |
| 50 return; | |
| 51 } else | |
| 52 /* 1.0 gamma is identity */ | |
|
1869
65800e7f7146
Date: Fri, 9 Jun 2006 11:35:23 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
1612
diff
changeset
|
53 if ( gamma == 1.0f ) { |
| 0 | 54 for ( i=0; i<256; ++i ) { |
| 55 ramp[i] = (i << 8) | i; | |
| 56 } | |
| 57 return; | |
| 58 } else | |
| 59 /* Calculate a real gamma ramp */ | |
| 60 { int value; | |
| 61 gamma = 1.0f / gamma; | |
| 62 for ( i=0; i<256; ++i ) { | |
| 63 value = (int)(pow((double)i/256.0, gamma)*65535.0+0.5); | |
| 64 if ( value > 65535 ) { | |
| 65 value = 65535; | |
| 66 } | |
| 67 ramp[i] = (Uint16)value; | |
| 68 } | |
| 69 } | |
| 70 } | |
| 71 static void CalculateGammaFromRamp(float *gamma, Uint16 *ramp) | |
| 72 { | |
| 73 /* The following is adapted from a post by Garrett Bass on OpenGL | |
| 74 Gamedev list, March 4, 2000. | |
| 75 */ | |
|
1612
97d0966f4bf7
Fixed some ultra-pedantic gcc warnings
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
76 float sum = 0.0f; |
| 0 | 77 int i, count = 0; |
| 78 | |
| 79 *gamma = 1.0; | |
| 80 for ( i = 1; i < 256; ++i ) { | |
| 81 if ( (ramp[i] != 0) && (ramp[i] != 65535) ) { | |
| 82 double B = (double)i / 256.0; | |
| 83 double A = ramp[i] / 65535.0; | |
| 84 sum += (float) ( log(A) / log(B) ); | |
| 85 count++; | |
| 86 } | |
| 87 } | |
|
1612
97d0966f4bf7
Fixed some ultra-pedantic gcc warnings
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
88 if ( count && sum > 0.0f ) { |
| 0 | 89 *gamma = 1.0f / (sum / count); |
| 90 } | |
| 91 } | |
| 92 | |
| 93 int SDL_SetGamma(float red, float green, float blue) | |
| 94 { | |
| 95 int succeeded; | |
| 96 SDL_VideoDevice *video = current_video; | |
| 97 SDL_VideoDevice *this = current_video; | |
| 98 | |
| 99 succeeded = -1; | |
| 100 /* Prefer using SetGammaRamp(), as it's more flexible */ | |
| 101 { | |
| 102 Uint16 ramp[3][256]; | |
| 103 | |
| 104 CalculateGammaRamp(red, ramp[0]); | |
| 105 CalculateGammaRamp(green, ramp[1]); | |
| 106 CalculateGammaRamp(blue, ramp[2]); | |
| 107 succeeded = SDL_SetGammaRamp(ramp[0], ramp[1], ramp[2]); | |
| 108 } | |
| 109 if ( (succeeded < 0) && video->SetGamma ) { | |
| 110 SDL_ClearError(); | |
| 111 succeeded = video->SetGamma(this, red, green, blue); | |
| 112 } | |
| 113 return succeeded; | |
| 114 } | |
| 115 | |
| 116 /* Calculating the gamma by integrating the gamma ramps isn't exact, | |
| 117 so this function isn't officially supported. | |
| 118 */ | |
| 119 int SDL_GetGamma(float *red, float *green, float *blue) | |
| 120 { | |
| 121 int succeeded; | |
| 122 SDL_VideoDevice *video = current_video; | |
| 123 SDL_VideoDevice *this = current_video; | |
| 124 | |
| 125 succeeded = -1; | |
| 126 /* Prefer using GetGammaRamp(), as it's more flexible */ | |
| 127 { | |
| 128 Uint16 ramp[3][256]; | |
| 129 | |
| 130 succeeded = SDL_GetGammaRamp(ramp[0], ramp[1], ramp[2]); | |
| 131 if ( succeeded >= 0 ) { | |
| 132 CalculateGammaFromRamp(red, ramp[0]); | |
| 133 CalculateGammaFromRamp(green, ramp[1]); | |
| 134 CalculateGammaFromRamp(blue, ramp[2]); | |
| 135 } | |
| 136 } | |
| 137 if ( (succeeded < 0) && video->GetGamma ) { | |
| 138 SDL_ClearError(); | |
| 139 succeeded = video->GetGamma(this, red, green, blue); | |
| 140 } | |
| 141 return succeeded; | |
| 142 } | |
| 143 | |
|
669
37bb90b3d976
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
144 int SDL_SetGammaRamp(const Uint16 *red, const Uint16 *green, const Uint16 *blue) |
| 0 | 145 { |
| 146 int succeeded; | |
| 147 SDL_VideoDevice *video = current_video; | |
| 148 SDL_VideoDevice *this = current_video; | |
| 149 SDL_Surface *screen = SDL_PublicSurface; | |
| 150 | |
| 151 /* Verify the screen parameter */ | |
| 152 if ( !screen ) { | |
| 153 SDL_SetError("No video mode has been set"); | |
| 154 return -1; | |
| 155 } | |
| 156 | |
| 157 /* Lazily allocate the gamma tables */ | |
| 158 if ( ! video->gamma ) { | |
| 159 SDL_GetGammaRamp(0, 0, 0); | |
| 160 } | |
| 161 | |
| 162 /* Fill the gamma table with the new values */ | |
| 163 if ( red ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
164 SDL_memcpy(&video->gamma[0*256], red, 256*sizeof(*video->gamma)); |
| 0 | 165 } |
| 166 if ( green ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
167 SDL_memcpy(&video->gamma[1*256], green, 256*sizeof(*video->gamma)); |
| 0 | 168 } |
| 169 if ( blue ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
170 SDL_memcpy(&video->gamma[2*256], blue, 256*sizeof(*video->gamma)); |
| 0 | 171 } |
| 172 | |
| 173 /* Gamma correction always possible on split palettes */ | |
| 174 if ( (screen->flags & SDL_HWPALETTE) == SDL_HWPALETTE ) { | |
| 175 SDL_Palette *pal = screen->format->palette; | |
| 176 | |
| 177 /* If physical palette has been set independently, use it */ | |
| 178 if(video->physpal) | |
| 179 pal = video->physpal; | |
| 180 | |
| 181 SDL_SetPalette(screen, SDL_PHYSPAL, | |
| 182 pal->colors, 0, pal->ncolors); | |
| 183 return 0; | |
| 184 } | |
| 185 | |
| 186 /* Try to set the gamma ramp in the driver */ | |
| 187 succeeded = -1; | |
| 188 if ( video->SetGammaRamp ) { | |
| 189 succeeded = video->SetGammaRamp(this, video->gamma); | |
| 190 } else { | |
| 191 SDL_SetError("Gamma ramp manipulation not supported"); | |
| 192 } | |
| 193 return succeeded; | |
| 194 } | |
| 195 | |
| 196 int SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue) | |
| 197 { | |
| 198 SDL_VideoDevice *video = current_video; | |
| 199 SDL_VideoDevice *this = current_video; | |
| 200 | |
| 201 /* Lazily allocate the gamma table */ | |
| 202 if ( ! video->gamma ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
203 video->gamma = SDL_malloc(3*256*sizeof(*video->gamma)); |
| 0 | 204 if ( ! video->gamma ) { |
| 205 SDL_OutOfMemory(); | |
| 206 return -1; | |
| 207 } | |
| 208 if ( video->GetGammaRamp ) { | |
| 209 /* Get the real hardware gamma */ | |
| 210 video->GetGammaRamp(this, video->gamma); | |
| 211 } else { | |
| 212 /* Assume an identity gamma */ | |
| 213 int i; | |
| 214 for ( i=0; i<256; ++i ) { | |
| 215 video->gamma[0*256+i] = (i << 8) | i; | |
| 216 video->gamma[1*256+i] = (i << 8) | i; | |
| 217 video->gamma[2*256+i] = (i << 8) | i; | |
| 218 } | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 /* Just copy from our internal table */ | |
| 223 if ( red ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
224 SDL_memcpy(red, &video->gamma[0*256], 256*sizeof(*red)); |
| 0 | 225 } |
| 226 if ( green ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
227 SDL_memcpy(green, &video->gamma[1*256], 256*sizeof(*green)); |
| 0 | 228 } |
| 229 if ( blue ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1334
diff
changeset
|
230 SDL_memcpy(blue, &video->gamma[2*256], 256*sizeof(*blue)); |
| 0 | 231 } |
| 232 return 0; | |
| 233 } |