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_copy.h"
28
29
30
31
#include "SDL_RLEaccel_c.h"
#include "SDL_pixels_c.h"
/* The general purpose software blit routine */
32
33
34
static int
SDL_SoftBlit(SDL_Surface * src, SDL_Rect * srcrect,
SDL_Surface * dst, SDL_Rect * dstrect)
36
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
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) {
SDL_BlitInfo info;
SDL_loblit RunBlit;
/* Set up the blit information */
info.s_pixels = (Uint8 *) src->pixels +
(Uint16) srcrect->y * src->pitch +
(Uint16) srcrect->x * src->format->BytesPerPixel;
info.s_width = srcrect->w;
info.s_height = srcrect->h;
info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel;
info.d_pixels = (Uint8 *) dst->pixels +
(Uint16) dstrect->y * dst->pitch +
(Uint16) dstrect->x * dst->format->BytesPerPixel;
info.d_width = dstrect->w;
info.d_height = dstrect->h;
info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel;
info.src = src->format;
info.table = src->map->table;
info.dst = dst->format;
83
84
info.ckey = src->map->ckey;
info.cmod = src->map->cmod;
85
RunBlit = (SDL_loblit) src->map->data;
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/* Run the actual software blit */
RunBlit(&info);
}
/* 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);
100
101
}
102
103
#ifdef __MACOSX__
#include <sys/sysctl.h>
105
106
static SDL_bool
SDL_UseAltivecPrefetch()
108
109
110
const char key[] = "hw.l3cachesize";
u_int64_t result = 0;
size_t typeSize = sizeof(result);
112
113
114
115
if (sysctlbyname(key, &result, &typeSize, NULL, 0) == 0 && result > 0) {
return SDL_TRUE;
} else {
return SDL_FALSE;
119
120
static SDL_bool
SDL_UseAltivecPrefetch()
121
{
122
123
/* Just guess G4 */
return SDL_TRUE;
124
}
125
#endif /* __MACOSX__ */
127
128
static SDL_loblit
SDL_ChooseBlitFunc(SDL_BlitEntry * entries, int count)
129
{
130
131
132
133
int i;
static Uint32 features = 0xffffffff;
if (features == 0xffffffff) {
134
135
const char *override = SDL_getenv("SDL_BLIT_FEATURES");
136
features = SDL_BLIT_ANY;
138
/* Allow an override for testing .. */
139
140
141
142
143
144
145
146
147
if (override) {
SDL_sscanf(override, "%u", &features);
} else {
if (SDL_HasMMX()) {
features |= SDL_BLIT_MMX;
}
if (SDL_HasSSE()) {
features |= SDL_BLIT_SSE;
}
148
if (SDL_HasAltiVec()) {
149
150
151
152
153
154
if (SDL_UseAltivecPrefetch()) {
features |= SDL_BLIT_ALTIVEC_PREFETCH;
} else {
features |= SDL_BLIT_ALTIVEC_NOPREFETCH;
}
}
156
157
158
159
160
}
for (i = count; i > 0; --i) {
if (features & entries[i].features) {
return entries[i].blit;
163
return entries[0].blit;
164
165
166
}
/* Figure out which of many blit routines to set up on a surface */
167
168
int
SDL_CalculateBlit(SDL_Surface * surface)
169
{
170
SDL_loblit blit = NULL;
171
172
173
174
175
176
int blit_index;
/* Clean everything out to start */
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 1);
}
177
surface->map->blit = NULL;
178
179
180
181
182
183
/* Get the blit function index, based on surface mode */
/* { 0 = nothing, 1 = colorkey, 2 = alpha, 3 = colorkey+alpha } */
blit_index = 0;
blit_index |= (!!(surface->flags & SDL_SRCCOLORKEY)) << 0;
if (surface->flags & SDL_SRCALPHA
184
&& ((surface->map->cmod >> 24) != SDL_ALPHA_OPAQUE
185
186
187
188
189
190
191
192
|| surface->format->Amask)) {
blit_index |= 2;
}
/* Check for special "identity" case -- copy blit */
if (surface->map->identity && blit_index == 0) {
/* Handle overlapping blits on the same surface */
if (surface == surface->map->dst) {
193
blit = SDL_BlitCopyOverlap;
195
blit = SDL_BlitCopy;
196
197
198
}
} else {
if (surface->format->BitsPerPixel < 8) {
199
blit = SDL_CalculateBlit0(surface, blit_index);
200
201
202
} else {
switch (surface->format->BytesPerPixel) {
case 1:
203
blit = SDL_CalculateBlit1(surface, blit_index);
204
205
206
207
break;
case 2:
case 3:
case 4:
208
blit = SDL_CalculateBlitN(surface, blit_index);
209
210
211
212
213
break;
}
}
}
/* Make sure we have a blit function */
214
if (blit == NULL) {
215
216
217
218
219
220
221
222
223
224
225
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)
226
surface->map->blit = SDL_RLEBlit;
227
228
} else if (blit_index == 2 && surface->format->Amask) {
if (SDL_RLESurface(surface) == 0)
229
surface->map->blit = SDL_RLEAlphaBlit;
233
234
235
if (surface->map->blit == NULL) {
surface->map->blit = SDL_SoftBlit;
surface->map->data = blit;
236
237
}
return (0);
238
239
}
240
/* vi: set ts=4 sw=4 expandtab: */