This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_blit.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 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.
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
30
31
32
#include "SDL_RLEaccel_c.h"
#include "SDL_pixels_c.h"
/* The general purpose software blit routine */
33
34
35
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
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) {
65
SDL_BlitFunc RunBlit;
66
SDL_BlitInfo *info = &src->map->info;
67
68
/* Set up the blit information */
69
info->src = (Uint8 *) src->pixels +
70
(Uint16) srcrect->y * src->pitch +
71
(Uint16) srcrect->x * info->src_fmt->BytesPerPixel;
72
73
info->src_w = srcrect->w;
info->src_h = srcrect->h;
74
75
76
77
info->src_skip =
info->src_pitch - info->src_w * info->src_fmt->BytesPerPixel;
info->dst =
(Uint8 *) dst->pixels + (Uint16) dstrect->y * dst->pitch +
78
(Uint16) dstrect->x * info->dst_fmt->BytesPerPixel;
79
80
info->dst_w = dstrect->w;
info->dst_h = dstrect->h;
81
82
info->dst_skip =
info->dst_pitch - info->dst_w * info->dst_fmt->BytesPerPixel;
83
RunBlit = (SDL_BlitFunc) src->map->data;
84
85
/* Run the actual software blit */
86
RunBlit(info);
87
88
89
90
91
92
93
94
95
96
97
}
/* 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);
98
99
}
100
101
#ifdef __MACOSX__
#include <sys/sysctl.h>
103
104
static SDL_bool
SDL_UseAltivecPrefetch()
106
107
108
const char key[] = "hw.l3cachesize";
u_int64_t result = 0;
size_t typeSize = sizeof(result);
110
111
112
113
if (sysctlbyname(key, &result, &typeSize, NULL, 0) == 0 && result > 0) {
return SDL_TRUE;
} else {
return SDL_FALSE;
117
118
static SDL_bool
SDL_UseAltivecPrefetch()
119
{
120
121
/* Just guess G4 */
return SDL_TRUE;
122
}
123
#endif /* __MACOSX__ */
125
static SDL_BlitFunc
126
127
SDL_ChooseBlitFunc(Uint32 src_format, Uint32 dst_format, int flags,
SDL_BlitFuncEntry * entries)
128
{
129
int i, flagcheck;
130
131
static Uint32 features = 0xffffffff;
132
/* Get the available CPU features */
133
if (features == 0xffffffff) {
134
const char *override = SDL_getenv("SDL_BLIT_CPU_FEATURES");
136
features = SDL_CPU_ANY;
138
/* Allow an override for testing .. */
139
140
141
142
if (override) {
SDL_sscanf(override, "%u", &features);
} else {
if (SDL_HasMMX()) {
143
144
145
146
features |= SDL_CPU_MMX;
}
if (SDL_Has3DNow()) {
features |= SDL_CPU_3DNOW;
147
148
}
if (SDL_HasSSE()) {
149
150
151
152
features |= SDL_CPU_SSE;
}
if (SDL_HasSSE2()) {
features |= SDL_CPU_SSE2;
154
if (SDL_HasAltiVec()) {
155
if (SDL_UseAltivecPrefetch()) {
156
features |= SDL_CPU_ALTIVEC_PREFETCH;
158
features |= SDL_CPU_ALTIVEC_NOPREFETCH;
164
for (i = 0; entries[i].func; ++i) {
165
/* Check for matching pixel formats */
166
167
168
169
170
171
if (src_format != entries[i].src_format) {
continue;
}
if (dst_format != entries[i].dst_format) {
continue;
}
172
173
/* Check modulation flags */
174
175
flagcheck =
(flags & (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_COLOR));
176
177
178
179
180
if ((flagcheck & entries[i].flags) != flagcheck) {
continue;
}
/* Check blend flags */
181
182
183
flagcheck =
(flags &
(SDL_COPY_MASK | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD));
184
185
186
187
188
189
190
191
192
193
194
195
196
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) {
199
200
201
202
/* Check CPU features */
flagcheck = entries[i].cpu;
if ((flagcheck & features) != flagcheck) {
203
204
continue;
}
205
206
/* We found the best one! */
207
return entries[i].func;
210
211
212
}
/* Figure out which of many blit routines to set up on a surface */
213
214
int
SDL_CalculateBlit(SDL_Surface * surface)
215
{
216
SDL_BlitFunc blit = NULL;
217
218
SDL_BlitMap *map = surface->map;
SDL_Surface *dst = map->dst;
219
220
221
222
223
/* Clean everything out to start */
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 1);
}
224
225
226
227
228
229
230
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 */
231
if (surface->map->info.flags & SDL_COPY_RLE_DESIRED) {
232
if (SDL_RLESurface(surface) == 0) {
233
surface->map->info.flags &= ~SDL_COPY_RLE_DESIRED;
234
235
236
return 0;
}
}
238
239
/* Choose a standard blit function */
if (map->identity && !map->info.flags) {
240
/* Handle overlapping blits on the same surface */
241
if (surface == dst) {
242
blit = SDL_BlitCopyOverlap;
244
blit = SDL_BlitCopy;
246
} else if (surface->format->BitsPerPixel < 8) {
247
blit = SDL_CalculateBlit0(surface);
248
} else if (surface->format->BytesPerPixel == 1) {
249
250
251
blit = SDL_CalculateBlit1(surface);
} else if (map->info.flags & SDL_COPY_BLEND) {
blit = SDL_CalculateBlitA(surface);
253
blit = SDL_CalculateBlitN(surface);
255
if (blit == NULL) {
256
257
258
259
260
261
262
263
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,
264
dst->format->Rmask,
265
dst->format->Gmask,
266
267
268
269
270
271
dst->format->Bmask,
dst->format->Amask);
blit =
SDL_ChooseBlitFunc(src_format, dst_format, map->info.flags,
SDL_GeneratedBlitFuncTable);
273
map->data = blit;
275
/* Make sure we have a blit function */
276
if (blit == NULL) {
277
SDL_InvalidateMap(map);
278
279
280
281
282
SDL_SetError("Blit combination not supported");
return (-1);
}
return (0);
283
284
}
285
/* vi: set ts=4 sw=4 expandtab: */