This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_blit.c
296 lines (262 loc) · 8.54 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 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
26
#include "SDL_video.h"
#include "SDL_sysvideo.h"
#include "SDL_blit.h"
27
#include "SDL_blit_auto.h"
28
#include "SDL_blit_copy.h"
29
#include "SDL_blit_slow.h"
30
31
32
33
#include "SDL_RLEaccel_c.h"
#include "SDL_pixels_c.h"
/* The general purpose software blit routine */
34
35
36
static int
SDL_SoftBlit(SDL_Surface * src, SDL_Rect * srcrect,
SDL_Surface * dst, SDL_Rect * dstrect)
37
{
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
int okay;
int src_locked;
int dst_locked;
/* Everything is okay at the beginning... */
okay = 1;
/* Lock the destination if it's in hardware */
dst_locked = 0;
if (SDL_MUSTLOCK(dst)) {
if (SDL_LockSurface(dst) < 0) {
okay = 0;
} else {
dst_locked = 1;
}
}
/* Lock the source if it's in hardware */
src_locked = 0;
if (SDL_MUSTLOCK(src)) {
if (SDL_LockSurface(src) < 0) {
okay = 0;
} else {
src_locked = 1;
}
}
/* Set up source and destination buffer pointers, and BLIT! */
if (okay && srcrect->w && srcrect->h) {
66
SDL_BlitFunc RunBlit;
67
SDL_BlitInfo *info = &src->map->info;
68
69
/* Set up the blit information */
70
info->src = (Uint8 *) src->pixels +
71
(Uint16) srcrect->y * src->pitch +
72
(Uint16) srcrect->x * info->src_fmt->BytesPerPixel;
73
74
info->src_w = srcrect->w;
info->src_h = srcrect->h;
75
info->src_pitch = src->pitch;
76
77
78
79
info->src_skip =
info->src_pitch - info->src_w * info->src_fmt->BytesPerPixel;
info->dst =
(Uint8 *) dst->pixels + (Uint16) dstrect->y * dst->pitch +
80
(Uint16) dstrect->x * info->dst_fmt->BytesPerPixel;
81
82
info->dst_w = dstrect->w;
info->dst_h = dstrect->h;
83
info->dst_pitch = dst->pitch;
84
85
info->dst_skip =
info->dst_pitch - info->dst_w * info->dst_fmt->BytesPerPixel;
86
RunBlit = (SDL_BlitFunc) src->map->data;
87
88
/* Run the actual software blit */
89
RunBlit(info);
90
91
92
93
94
95
96
97
98
99
100
}
/* We need to unlock the surfaces if they're locked */
if (dst_locked) {
SDL_UnlockSurface(dst);
}
if (src_locked) {
SDL_UnlockSurface(src);
}
/* Blit is done! */
return (okay ? 0 : -1);
101
102
}
103
104
#ifdef __MACOSX__
#include <sys/sysctl.h>
105
106
107
static SDL_bool
SDL_UseAltivecPrefetch()
108
{
109
110
111
const char key[] = "hw.l3cachesize";
u_int64_t result = 0;
size_t typeSize = sizeof(result);
112
113
114
115
116
if (sysctlbyname(key, &result, &typeSize, NULL, 0) == 0 && result > 0) {
return SDL_TRUE;
} else {
return SDL_FALSE;
117
}
118
}
119
#else
120
121
static SDL_bool
SDL_UseAltivecPrefetch()
122
{
123
124
/* Just guess G4 */
return SDL_TRUE;
125
}
126
#endif /* __MACOSX__ */
127
128
static SDL_BlitFunc
129
130
SDL_ChooseBlitFunc(Uint32 src_format, Uint32 dst_format, int flags,
SDL_BlitFuncEntry * entries)
131
{
132
int i, flagcheck;
133
134
static Uint32 features = 0xffffffff;
135
/* Get the available CPU features */
136
if (features == 0xffffffff) {
137
const char *override = SDL_getenv("SDL_BLIT_CPU_FEATURES");
138
139
features = SDL_CPU_ANY;
140
141
/* Allow an override for testing .. */
142
143
144
145
if (override) {
SDL_sscanf(override, "%u", &features);
} else {
if (SDL_HasMMX()) {
146
147
148
149
features |= SDL_CPU_MMX;
}
if (SDL_Has3DNow()) {
features |= SDL_CPU_3DNOW;
150
151
}
if (SDL_HasSSE()) {
152
153
154
155
features |= SDL_CPU_SSE;
}
if (SDL_HasSSE2()) {
features |= SDL_CPU_SSE2;
156
}
157
if (SDL_HasAltiVec()) {
158
if (SDL_UseAltivecPrefetch()) {
159
features |= SDL_CPU_ALTIVEC_PREFETCH;
160
} else {
161
features |= SDL_CPU_ALTIVEC_NOPREFETCH;
162
163
}
}
164
}
165
166
}
167
for (i = 0; entries[i].func; ++i) {
168
/* Check for matching pixel formats */
169
170
171
172
173
174
if (src_format != entries[i].src_format) {
continue;
}
if (dst_format != entries[i].dst_format) {
continue;
}
175
176
/* Check modulation flags */
177
flagcheck =
178
(flags & (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA));
179
180
181
182
183
if ((flagcheck & entries[i].flags) != flagcheck) {
continue;
}
/* Check blend flags */
184
185
186
flagcheck =
(flags &
(SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD));
187
188
189
190
191
192
193
194
195
196
197
198
199
if ((flagcheck & entries[i].flags) != flagcheck) {
continue;
}
/* Check colorkey flag */
flagcheck = (flags & SDL_COPY_COLORKEY);
if ((flagcheck & entries[i].flags) != flagcheck) {
continue;
}
/* Check scaling flags */
flagcheck = (flags & SDL_COPY_NEAREST);
if ((flagcheck & entries[i].flags) != flagcheck) {
200
continue;
201
}
202
203
204
205
/* Check CPU features */
flagcheck = entries[i].cpu;
if ((flagcheck & features) != flagcheck) {
206
207
continue;
}
208
209
/* We found the best one! */
210
return entries[i].func;
211
}
212
return NULL;
213
214
215
}
/* Figure out which of many blit routines to set up on a surface */
216
217
int
SDL_CalculateBlit(SDL_Surface * surface)
218
{
219
SDL_BlitFunc blit = NULL;
220
221
SDL_BlitMap *map = surface->map;
SDL_Surface *dst = map->dst;
222
223
224
225
226
/* Clean everything out to start */
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 1);
}
227
228
229
230
231
232
233
map->blit = SDL_SoftBlit;
map->info.src_fmt = surface->format;
map->info.src_pitch = surface->pitch;
map->info.dst_fmt = dst->format;
map->info.dst_pitch = dst->pitch;
/* See if we can do RLE acceleration */
234
if (map->info.flags & SDL_COPY_RLE_DESIRED) {
235
236
237
238
if (SDL_RLESurface(surface) == 0) {
return 0;
}
}
239
240
/* Choose a standard blit function */
241
if (map->identity && !(map->info.flags & ~SDL_COPY_RLE_DESIRED)) {
242
/* Handle overlapping blits on the same surface */
243
if (surface == dst) {
244
blit = SDL_BlitCopyOverlap;
245
} else {
246
blit = SDL_BlitCopy;
247
}
248
} else if (surface->format->BitsPerPixel < 8) {
249
blit = SDL_CalculateBlit0(surface);
250
} else if (surface->format->BytesPerPixel == 1) {
251
252
253
blit = SDL_CalculateBlit1(surface);
} else if (map->info.flags & SDL_COPY_BLEND) {
blit = SDL_CalculateBlitA(surface);
254
} else {
255
blit = SDL_CalculateBlitN(surface);
256
}
257
if (blit == NULL) {
258
259
260
261
262
263
264
265
Uint32 src_format =
SDL_MasksToPixelFormatEnum(surface->format->BitsPerPixel,
surface->format->Rmask,
surface->format->Gmask,
surface->format->Bmask,
surface->format->Amask);
Uint32 dst_format =
SDL_MasksToPixelFormatEnum(dst->format->BitsPerPixel,
266
dst->format->Rmask,
267
dst->format->Gmask,
268
269
270
271
272
273
dst->format->Bmask,
dst->format->Amask);
blit =
SDL_ChooseBlitFunc(src_format, dst_format, map->info.flags,
SDL_GeneratedBlitFuncTable);
274
}
275
276
277
278
279
280
281
282
283
#ifndef TEST_SLOW_BLIT
if (blit == NULL)
#endif
{
if (surface->format->BytesPerPixel > 1
&& dst->format->BytesPerPixel > 1) {
blit = SDL_Blit_Slow;
}
}
284
map->data = blit;
285
286
/* Make sure we have a blit function */
287
if (blit == NULL) {
288
SDL_InvalidateMap(map);
289
290
291
292
293
SDL_SetError("Blit combination not supported");
return (-1);
}
return (0);
294
295
}
296
/* vi: set ts=4 sw=4 expandtab: */