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
74
info->src_w = srcrect->w;
info->src_h = srcrect->h;
info->dst = (Uint8 *) dst->pixels +
75
(Uint16) dstrect->y * dst->pitch +
76
(Uint16) dstrect->x * info->dst_fmt->BytesPerPixel;
77
78
info->dst_w = dstrect->w;
info->dst_h = dstrect->h;
79
RunBlit = (SDL_BlitFunc) src->map->data;
80
81
/* Run the actual software blit */
82
RunBlit(info);
83
84
85
86
87
88
89
90
91
92
93
}
/* 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);
94
95
}
96
97
#ifdef __MACOSX__
#include <sys/sysctl.h>
99
100
static SDL_bool
SDL_UseAltivecPrefetch()
102
103
104
const char key[] = "hw.l3cachesize";
u_int64_t result = 0;
size_t typeSize = sizeof(result);
106
107
108
109
if (sysctlbyname(key, &result, &typeSize, NULL, 0) == 0 && result > 0) {
return SDL_TRUE;
} else {
return SDL_FALSE;
113
114
static SDL_bool
SDL_UseAltivecPrefetch()
115
{
116
117
/* Just guess G4 */
return SDL_TRUE;
118
}
119
#endif /* __MACOSX__ */
121
static SDL_BlitFunc
122
SDL_ChooseBlitFunc(Uint32 src_format, Uint32 dst_format, int flags, SDL_BlitFuncEntry * entries)
123
{
124
125
126
int i;
static Uint32 features = 0xffffffff;
127
/* Get the available CPU features */
128
if (features == 0xffffffff) {
129
const char *override = SDL_getenv("SDL_BLIT_CPU_FEATURES");
131
features = SDL_CPU_ANY;
133
/* Allow an override for testing .. */
134
135
136
137
if (override) {
SDL_sscanf(override, "%u", &features);
} else {
if (SDL_HasMMX()) {
138
139
140
141
features |= SDL_CPU_MMX;
}
if (SDL_Has3DNow()) {
features |= SDL_CPU_3DNOW;
142
143
}
if (SDL_HasSSE()) {
144
145
146
147
features |= SDL_CPU_SSE;
}
if (SDL_HasSSE2()) {
features |= SDL_CPU_SSE2;
149
if (SDL_HasAltiVec()) {
150
if (SDL_UseAltivecPrefetch()) {
151
features |= SDL_CPU_ALTIVEC_PREFETCH;
153
features |= SDL_CPU_ALTIVEC_NOPREFETCH;
159
for (i = 0; entries[i].func; ++i) {
160
161
162
163
164
165
166
167
if (src_format != entries[i].src_format) {
continue;
}
if (dst_format != entries[i].dst_format) {
continue;
}
if ((flags & entries[i].flags) != flags) {
continue;
169
170
171
172
if (!(features & entries[i].cpu)) {
continue;
}
return entries[i].func;
175
176
177
}
/* Figure out which of many blit routines to set up on a surface */
178
179
int
SDL_CalculateBlit(SDL_Surface * surface)
180
{
181
SDL_BlitFunc blit = NULL;
182
183
184
SDL_Surface *dst = surface->map->dst;
Uint32 src_format;
Uint32 dst_format;
185
186
187
188
189
/* Clean everything out to start */
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 1);
}
190
surface->map->blit = NULL;
191
192
193
194
surface->map->info.src_fmt = surface->format;
surface->map->info.src_pitch = surface->pitch;
surface->map->info.dst_fmt = dst->format;
surface->map->info.dst_pitch = dst->pitch;
196
197
src_format = SDL_MasksToPixelFormatEnum(surface->format->BitsPerPixel, surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask);
dst_format = SDL_MasksToPixelFormatEnum(dst->format->BitsPerPixel, dst->format->Rmask, dst->format->Gmask, dst->format->Bmask, dst->format->Amask);
198
199
/* Check for special "identity" case -- copy blit */
200
if (surface->map->identity && !surface->map->info.flags) {
201
/* Handle overlapping blits on the same surface */
202
if (surface == dst) {
203
blit = SDL_BlitCopyOverlap;
205
blit = SDL_BlitCopy;
206
207
208
}
} else {
if (surface->format->BitsPerPixel < 8) {
209
blit = SDL_ChooseBlitFunc(src_format, dst_format, surface->map->info.flags, SDL_BlitFuncTable0);
210
211
212
} else {
switch (surface->format->BytesPerPixel) {
case 1:
213
blit = SDL_ChooseBlitFunc(src_format, dst_format, surface->map->info.flags, SDL_BlitFuncTable1);
214
215
216
217
break;
case 2:
case 3:
case 4:
218
blit = SDL_ChooseBlitFunc(src_format, dst_format, surface->map->info.flags, SDL_BlitFuncTableN);
219
220
221
222
break;
}
}
}
223
224
225
226
if (blit == NULL) {
blit = SDL_ChooseBlitFunc(src_format, dst_format, surface->map->info.flags, SDL_GeneratedBlitFuncTable);
}
227
/* Make sure we have a blit function */
228
if (blit == NULL) {
229
230
231
232
233
234
235
236
237
238
239
SDL_InvalidateMap(surface->map);
SDL_SetError("Blit combination not supported");
return (-1);
}
/* Choose software blitting function */
if (surface->flags & SDL_RLEACCELOK) {
if (surface->map->identity
&& (blit_index == 1
|| (blit_index == 3 && !surface->format->Amask))) {
if (SDL_RLESurface(surface) == 0)
240
surface->map->blit = SDL_RLEBlit;
241
242
} else if (blit_index == 2 && surface->format->Amask) {
if (SDL_RLESurface(surface) == 0)
243
surface->map->blit = SDL_RLEAlphaBlit;
247
248
249
if (surface->map->blit == NULL) {
surface->map->blit = SDL_SoftBlit;
surface->map->data = blit;
250
251
}
return (0);
252
253
}
254
/* vi: set ts=4 sw=4 expandtab: */