?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Don't hide GL function pointer typedefs behind extension defines.
[wine.git] / dlls / winex11.drv / bitblt.c
blob8d2383a71457ffebc85626f43e3ae83036975da4
1 /*
2 * GDI bit-blit operations
3 *
4 * Copyright 1993, 1994, 2011 Alexandre Julliard
5 * Copyright 2006 Damjan Jovanovic
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #include <assert.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "winternl.h"
34 #include "x11drv.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(bitblt);
38
39
40 #define DST 0 /* Destination drawable */
41 #define SRC 1 /* Source drawable */
42 #define TMP 2 /* Temporary drawable */
43 #define PAT 3 /* Pattern (brush) in destination DC */
44
45 #define OP(src,dst,rop) (OP_ARGS(src,dst) << 4 | (rop))
46 #define OP_ARGS(src,dst) (((src) << 2) | (dst))
47
48 #define OP_SRC(opcode) ((opcode) >> 6)
49 #define OP_DST(opcode) (((opcode) >> 4) & 3)
50 #define OP_SRCDST(opcode) ((opcode) >> 4)
51 #define OP_ROP(opcode) ((opcode) & 0x0f)
52
53 #define MAX_OP_LEN 6 /* Longest opcode + 1 for the terminating 0 */
54
55 #define SWAP_INT32(i1,i2) \
56 do { INT __t = *(i1); *(i1) = *(i2); *(i2) = __t; } while(0)
57
58 static const unsigned char BITBLT_Opcodes[256][MAX_OP_LEN] =
59 {
60 { OP(PAT,DST,GXclear) }, /* 0x00 0 */
61 { OP(PAT,SRC,GXor), OP(SRC,DST,GXnor) }, /* 0x01 ~(D|(P|S)) */
62 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXand) }, /* 0x02 D&~(P|S) */
63 { OP(PAT,SRC,GXnor) }, /* 0x03 ~(P|S) */
64 { OP(PAT,DST,GXnor), OP(SRC,DST,GXand) }, /* 0x04 S&~(D|P) */
65 { OP(PAT,DST,GXnor) }, /* 0x05 ~(D|P) */
66 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXnor), }, /* 0x06 ~(P|~(D^S)) */
67 { OP(SRC,DST,GXand), OP(PAT,DST,GXnor) }, /* 0x07 ~(P|(D&S)) */
68 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXand) },/* 0x08 S&D&~P */
69 { OP(SRC,DST,GXxor), OP(PAT,DST,GXnor) }, /* 0x09 ~(P|(D^S)) */
70 { OP(PAT,DST,GXandInverted) }, /* 0x0a D&~P */
71 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXnor) }, /* 0x0b ~(P|(S&~D)) */
72 { OP(PAT,SRC,GXandInverted) }, /* 0x0c S&~P */
73 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXnor) },/* 0x0d ~(P|(D&~S)) */
74 { OP(SRC,DST,GXnor), OP(PAT,DST,GXnor) }, /* 0x0e ~(P|~(D|S)) */
75 { OP(PAT,DST,GXcopyInverted) }, /* 0x0f ~P */
76 { OP(SRC,DST,GXnor), OP(PAT,DST,GXand) }, /* 0x10 P&~(S|D) */
77 { OP(SRC,DST,GXnor) }, /* 0x11 ~(D|S) */
78 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXnor) }, /* 0x12 ~(S|~(D^P)) */
79 { OP(PAT,DST,GXand), OP(SRC,DST,GXnor) }, /* 0x13 ~(S|(D&P)) */
80 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXnor) }, /* 0x14 ~(D|~(P^S)) */
81 { OP(PAT,SRC,GXand), OP(SRC,DST,GXnor) }, /* 0x15 ~(D|(P&S)) */
82 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnand),
83 OP(SRC,DST,GXand), OP(TMP,DST,GXxor),
84 OP(PAT,DST,GXxor) }, /* 0x16 P^S^(D&~(P&S) */
85 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
86 OP(PAT,SRC,GXxor), OP(SRC,DST,GXand),
87 OP(TMP,DST,GXequiv) }, /* 0x17 ~S^((S^P)&(S^D))*/
88 { OP(PAT,SRC,GXxor), OP(PAT,DST,GXxor),
89 OP(SRC,DST,GXand) }, /* 0x18 (S^P)&(D^P) */
90 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnand),
91 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x19 ~S^(D&~(P&S)) */
92 { OP(PAT,SRC,GXand), OP(SRC,DST,GXor),
93 OP(PAT,DST,GXxor) }, /* 0x1a P^(D|(S&P)) */
94 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
95 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x1b ~S^(D&(P^S)) */
96 { OP(PAT,DST,GXand), OP(SRC,DST,GXor),
97 OP(PAT,DST,GXxor) }, /* 0x1c P^(S|(D&P)) */
98 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
99 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x1d ~D^(S&(D^P)) */
100 { OP(SRC,DST,GXor), OP(PAT,DST,GXxor) }, /* 0x1e P^(D|S) */
101 { OP(SRC,DST,GXor), OP(PAT,DST,GXnand) }, /* 0x1f ~(P&(D|S)) */
102 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXand) }, /* 0x20 D&(P&~S) */
103 { OP(PAT,DST,GXxor), OP(SRC,DST,GXnor) }, /* 0x21 ~(S|(D^P)) */
104 { OP(SRC,DST,GXandInverted) }, /* 0x22 ~S&D */
105 { OP(PAT,DST,GXandReverse), OP(SRC,DST,GXnor) }, /* 0x23 ~(S|(P&~D)) */
106 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
107 OP(SRC,DST,GXand) }, /* 0x24 (S^P)&(S^D) */
108 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXand),
109 OP(PAT,DST,GXequiv) }, /* 0x25 ~P^(D&~(S&P)) */
110 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXand),
111 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x26 S^(D|(S&P)) */
112 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXequiv),
113 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x27 S^(D|~(P^S)) */
114 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXand) }, /* 0x28 D&(P^S) */
115 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXand),
116 OP(SRC,DST,GXor), OP(TMP,DST,GXxor),
117 OP(PAT,DST,GXequiv) }, /* 0x29 ~P^S^(D|(P&S)) */
118 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXand) }, /* 0x2a D&~(P&S) */
119 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
120 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
121 OP(TMP,DST,GXequiv) }, /* 0x2b ~S^((P^S)&(P^D))*/
122 { OP(SRC,DST,GXor), OP(PAT,DST,GXand),
123 OP(SRC,DST,GXxor) }, /* 0x2c S^(P&(S|D)) */
124 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXxor) }, /* 0x2d P^(S|~D) */
125 { OP(PAT,DST,GXxor), OP(SRC,DST,GXor),
126 OP(PAT,DST,GXxor) }, /* 0x2e P^(S|(D^P)) */
127 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXnand) }, /* 0x2f ~(P&(S|~D)) */
128 { OP(PAT,SRC,GXandReverse) }, /* 0x30 P&~S */
129 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXnor) },/* 0x31 ~(S|(D&~P)) */
130 { OP(SRC,DST,GXor), OP(PAT,DST,GXor),
131 OP(SRC,DST,GXxor) }, /* 0x32 S^(D|P|S) */
132 { OP(SRC,DST,GXcopyInverted) }, /* 0x33 ~S */
133 { OP(SRC,DST,GXand), OP(PAT,DST,GXor),
134 OP(SRC,DST,GXxor) }, /* 0x34 S^(P|(D&S)) */
135 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXor),
136 OP(SRC,DST,GXxor) }, /* 0x35 S^(P|~(D^S)) */
137 { OP(PAT,DST,GXor), OP(SRC,DST,GXxor) }, /* 0x36 S^(D|P) */
138 { OP(PAT,DST,GXor), OP(SRC,DST,GXnand) }, /* 0x37 ~(S&(D|P)) */
139 { OP(PAT,DST,GXor), OP(SRC,DST,GXand),
140 OP(PAT,DST,GXxor) }, /* 0x38 P^(S&(D|P)) */
141 { OP(PAT,DST,GXorReverse), OP(SRC,DST,GXxor) }, /* 0x39 S^(P|~D) */
142 { OP(SRC,DST,GXxor), OP(PAT,DST,GXor),
143 OP(SRC,DST,GXxor) }, /* 0x3a S^(P|(D^S)) */
144 { OP(PAT,DST,GXorReverse), OP(SRC,DST,GXnand) }, /* 0x3b ~(S&(P|~D)) */
145 { OP(PAT,SRC,GXxor) }, /* 0x3c P^S */
146 { OP(SRC,DST,GXnor), OP(PAT,DST,GXor),
147 OP(SRC,DST,GXxor) }, /* 0x3d S^(P|~(D|S)) */
148 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXor),
149 OP(SRC,DST,GXxor) }, /* 0x3e S^(P|(D&~S)) */
150 { OP(PAT,SRC,GXnand) }, /* 0x3f ~(P&S) */
151 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXand) }, /* 0x40 P&S&~D */
152 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXnor) }, /* 0x41 ~(D|(P^S)) */
153 { OP(DST,SRC,GXxor), OP(PAT,DST,GXxor),
154 OP(SRC,DST,GXand) }, /* 0x42 (S^D)&(P^D) */
155 { OP(SRC,DST,GXnand), OP(PAT,DST,GXand),
156 OP(SRC,DST,GXequiv) }, /* 0x43 ~S^(P&~(D&S)) */
157 { OP(SRC,DST,GXandReverse) }, /* 0x44 S&~D */
158 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXnor) }, /* 0x45 ~(D|(P&~S)) */
159 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
160 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x46 D^(S|(P&D)) */
161 { OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
162 OP(PAT,DST,GXequiv) }, /* 0x47 ~P^(S&(D^P)) */
163 { OP(PAT,DST,GXxor), OP(SRC,DST,GXand) }, /* 0x48 S&(P^D) */
164 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
165 OP(SRC,DST,GXor), OP(TMP,DST,GXxor),
166 OP(PAT,DST,GXequiv) }, /* 0x49 ~P^D^(S|(P&D)) */
167 { OP(DST,SRC,GXor), OP(PAT,SRC,GXand),
168 OP(SRC,DST,GXxor) }, /* 0x4a D^(P&(S|D)) */
169 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXxor) }, /* 0x4b P^(D|~S) */
170 { OP(PAT,DST,GXnand), OP(SRC,DST,GXand) }, /* 0x4c S&~(D&P) */
171 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
172 OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
173 OP(TMP,DST,GXequiv) }, /* 0x4d ~S^((S^P)|(S^D))*/
174 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
175 OP(PAT,DST,GXxor) }, /* 0x4e P^(D|(S^P)) */
176 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXnand) },/* 0x4f ~(P&(D|~S)) */
177 { OP(PAT,DST,GXandReverse) }, /* 0x50 P&~D */
178 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXnor) },/* 0x51 ~(D|(S&~P)) */
179 { OP(DST,SRC,GXand), OP(PAT,SRC,GXor),
180 OP(SRC,DST,GXxor) }, /* 0x52 D^(P|(S&D)) */
181 { OP(SRC,DST,GXxor), OP(PAT,DST,GXand),
182 OP(SRC,DST,GXequiv) }, /* 0x53 ~S^(P&(D^S)) */
183 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXnor) }, /* 0x54 ~(D|~(P|S)) */
184 { OP(PAT,DST,GXinvert) }, /* 0x55 ~D */
185 { OP(PAT,SRC,GXor), OP(SRC,DST,GXxor) }, /* 0x56 D^(P|S) */
186 { OP(PAT,SRC,GXor), OP(SRC,DST,GXnand) }, /* 0x57 ~(D&(P|S)) */
187 { OP(PAT,SRC,GXor), OP(SRC,DST,GXand),
188 OP(PAT,DST,GXxor) }, /* 0x58 P^(D&(P|S)) */
189 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXxor) }, /* 0x59 D^(P|~S) */
190 { OP(PAT,DST,GXxor) }, /* 0x5a D^P */
191 { OP(DST,SRC,GXnor), OP(PAT,SRC,GXor),
192 OP(SRC,DST,GXxor) }, /* 0x5b D^(P|~(S|D)) */
193 { OP(DST,SRC,GXxor), OP(PAT,SRC,GXor),
194 OP(SRC,DST,GXxor) }, /* 0x5c D^(P|(S^D)) */
195 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXnand) }, /* 0x5d ~(D&(P|~S)) */
196 { OP(DST,SRC,GXandInverted), OP(PAT,SRC,GXor),
197 OP(SRC,DST,GXxor) }, /* 0x5e D^(P|(S&~D)) */
198 { OP(PAT,DST,GXnand) }, /* 0x5f ~(D&P) */
199 { OP(SRC,DST,GXxor), OP(PAT,DST,GXand) }, /* 0x60 P&(D^S) */
200 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXand),
201 OP(PAT,DST,GXor), OP(SRC,DST,GXxor),
202 OP(TMP,DST,GXequiv) }, /* 0x61 ~D^S^(P|(D&S)) */
203 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
204 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0x62 D^(S&(P|D)) */
205 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXxor) }, /* 0x63 S^(D|~P) */
206 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
207 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0x64 S^(D&(P|S)) */
208 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXxor) }, /* 0x65 D^(S|~P) */
209 { OP(SRC,DST,GXxor) }, /* 0x66 S^D */
210 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnor),
211 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x67 S^(D|~(S|P) */
212 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXnor),
213 OP(PAT,DST,GXor), OP(SRC,DST,GXxor),
214 OP(TMP,DST,GXequiv) }, /* 0x68 ~D^S^(P|~(D|S))*/
215 { OP(SRC,DST,GXxor), OP(PAT,DST,GXequiv) }, /* 0x69 ~P^(D^S) */
216 { OP(PAT,SRC,GXand), OP(SRC,DST,GXxor) }, /* 0x6a D^(P&S) */
217 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
218 OP(SRC,DST,GXand), OP(TMP,DST,GXxor),
219 OP(PAT,DST,GXequiv) }, /* 0x6b ~P^S^(D&(P|S)) */
220 { OP(PAT,DST,GXand), OP(SRC,DST,GXxor) }, /* 0x6c S^(D&P) */
221 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
222 OP(SRC,DST,GXand), OP(TMP,DST,GXxor),
223 OP(PAT,DST,GXequiv) }, /* 0x6d ~P^D^(S&(P|D)) */
224 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXorReverse),
225 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0x6e S^(D&(P|~S)) */
226 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXnand) }, /* 0x6f ~(P&~(S^D)) */
227 { OP(SRC,DST,GXnand), OP(PAT,DST,GXand) }, /* 0x70 P&~(D&S) */
228 { OP(SRC,TMP,GXcopy), OP(DST,SRC,GXxor),
229 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
230 OP(TMP,DST,GXequiv) }, /* 0x71 ~S^((S^D)&(P^D))*/
231 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
232 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x72 S^(D|(P^S)) */
233 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXnand) },/* 0x73 ~(S&(D|~P)) */
234 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
235 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x74 D^(S|(P^D)) */
236 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXnand) },/* 0x75 ~(D&(S|~P)) */
237 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXandReverse),
238 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x76 S^(D|(P&~S)) */
239 { OP(SRC,DST,GXnand) }, /* 0x77 ~(S&D) */
240 { OP(SRC,DST,GXand), OP(PAT,DST,GXxor) }, /* 0x78 P^(D&S) */
241 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXor),
242 OP(PAT,DST,GXand), OP(SRC,DST,GXxor),
243 OP(TMP,DST,GXequiv) }, /* 0x79 ~D^S^(P&(D|S)) */
244 { OP(DST,SRC,GXorInverted), OP(PAT,SRC,GXand),
245 OP(SRC,DST,GXxor) }, /* 0x7a D^(P&(S|~D)) */
246 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXnand) }, /* 0x7b ~(S&~(D^P)) */
247 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXand),
248 OP(SRC,DST,GXxor) }, /* 0x7c S^(P&(D|~S)) */
249 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXnand) }, /* 0x7d ~(D&~(P^S)) */
250 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
251 OP(SRC,DST,GXor) }, /* 0x7e (S^P)|(S^D) */
252 { OP(PAT,SRC,GXand), OP(SRC,DST,GXnand) }, /* 0x7f ~(D&P&S) */
253 { OP(PAT,SRC,GXand), OP(SRC,DST,GXand) }, /* 0x80 D&P&S */
254 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
255 OP(SRC,DST,GXnor) }, /* 0x81 ~((S^P)|(S^D)) */
256 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXand) }, /* 0x82 D&~(P^S) */
257 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXand),
258 OP(SRC,DST,GXequiv) }, /* 0x83 ~S^(P&(D|~S)) */
259 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXand) }, /* 0x84 S&~(D^P) */
260 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXand),
261 OP(PAT,DST,GXequiv) }, /* 0x85 ~P^(D&(S|~P)) */
262 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXor),
263 OP(PAT,DST,GXand), OP(SRC,DST,GXxor),
264 OP(TMP,DST,GXxor) }, /* 0x86 D^S^(P&(D|S)) */
265 { OP(SRC,DST,GXand), OP(PAT,DST,GXequiv) }, /* 0x87 ~P^(D&S) */
266 { OP(SRC,DST,GXand) }, /* 0x88 S&D */
267 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXandReverse),
268 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x89 ~S^(D|(P&~S)) */
269 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXand) }, /* 0x8a D&(S|~P) */
270 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
271 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x8b ~D^(S|(P^D)) */
272 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXand) }, /* 0x8c S&(D|~P) */
273 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
274 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x8d ~S^(D|(P^S)) */
275 { OP(SRC,TMP,GXcopy), OP(DST,SRC,GXxor),
276 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
277 OP(TMP,DST,GXxor) }, /* 0x8e S^((S^D)&(P^D))*/
278 { OP(SRC,DST,GXnand), OP(PAT,DST,GXnand) }, /* 0x8f ~(P&~(D&S)) */
279 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXand) }, /* 0x90 P&~(D^S) */
280 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXorReverse),
281 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x91 ~S^(D&(P|~S)) */
282 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
283 OP(SRC,DST,GXand), OP(PAT,DST,GXxor),
284 OP(TMP,DST,GXxor) }, /* 0x92 D^P^(S&(D|P)) */
285 { OP(PAT,DST,GXand), OP(SRC,DST,GXequiv) }, /* 0x93 ~S^(P&D) */
286 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
287 OP(SRC,DST,GXand), OP(PAT,DST,GXxor),
288 OP(TMP,DST,GXxor) }, /* 0x94 S^P^(D&(P|S)) */
289 { OP(PAT,SRC,GXand), OP(SRC,DST,GXequiv) }, /* 0x95 ~D^(P&S) */
290 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXxor) }, /* 0x96 D^P^S */
291 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnor),
292 OP(SRC,DST,GXor), OP(PAT,DST,GXxor),
293 OP(TMP,DST,GXxor) }, /* 0x97 S^P^(D|~(P|S)) */
294 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnor),
295 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x98 ~S^(D|~(P|S)) */
296 { OP(SRC,DST,GXequiv) }, /* 0x99 ~S^D */
297 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXxor) }, /* 0x9a D^(P&~S) */
298 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
299 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x9b ~S^(D&(P|S)) */
300 { OP(PAT,DST,GXandReverse), OP(SRC,DST,GXxor) }, /* 0x9c S^(P&~D) */
301 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
302 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x9d ~D^(S&(P|D)) */
303 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXand),
304 OP(PAT,DST,GXor), OP(SRC,DST,GXxor),
305 OP(TMP,DST,GXxor) }, /* 0x9e D^S^(P|(D&S)) */
306 { OP(SRC,DST,GXxor), OP(PAT,DST,GXnand) }, /* 0x9f ~(P&(D^S)) */
307 { OP(PAT,DST,GXand) }, /* 0xa0 D&P */
308 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXor),
309 OP(PAT,DST,GXequiv) }, /* 0xa1 ~P^(D|(S&~P)) */
310 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXand) }, /* 0xa2 D&(P|~S) */
311 { OP(DST,SRC,GXxor), OP(PAT,SRC,GXor),
312 OP(SRC,DST,GXequiv) }, /* 0xa3 ~D^(P|(S^D)) */
313 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXor),
314 OP(PAT,DST,GXequiv) }, /* 0xa4 ~P^(D|~(S|P)) */
315 { OP(PAT,DST,GXequiv) }, /* 0xa5 ~P^D */
316 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXxor) },/* 0xa6 D^(S&~P) */
317 { OP(PAT,SRC,GXor), OP(SRC,DST,GXand),
318 OP(PAT,DST,GXequiv) }, /* 0xa7 ~P^(D&(S|P)) */
319 { OP(PAT,SRC,GXor), OP(SRC,DST,GXand) }, /* 0xa8 D&(P|S) */
320 { OP(PAT,SRC,GXor), OP(SRC,DST,GXequiv) }, /* 0xa9 ~D^(P|S) */
321 { OP(PAT,DST,GXnoop) }, /* 0xaa D */
322 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXor) }, /* 0xab D|~(P|S) */
323 { OP(SRC,DST,GXxor), OP(PAT,DST,GXand),
324 OP(SRC,DST,GXxor) }, /* 0xac S^(P&(D^S)) */
325 { OP(DST,SRC,GXand), OP(PAT,SRC,GXor),
326 OP(SRC,DST,GXequiv) }, /* 0xad ~D^(P|(S&D)) */
327 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXor) }, /* 0xae D|(S&~P) */
328 { OP(PAT,DST,GXorInverted) }, /* 0xaf D|~P */
329 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXand) }, /* 0xb0 P&(D|~S) */
330 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
331 OP(PAT,DST,GXequiv) }, /* 0xb1 ~P^(D|(S^P)) */
332 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
333 OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
334 OP(TMP,DST,GXxor) }, /* 0xb2 S^((S^P)|(S^D))*/
335 { OP(PAT,DST,GXnand), OP(SRC,DST,GXnand) }, /* 0xb3 ~(S&~(D&P)) */
336 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXxor) }, /* 0xb4 P^(S&~D) */
337 { OP(DST,SRC,GXor), OP(PAT,SRC,GXand),
338 OP(SRC,DST,GXequiv) }, /* 0xb5 ~D^(P&(S|D)) */
339 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
340 OP(SRC,DST,GXor), OP(PAT,DST,GXxor),
341 OP(TMP,DST,GXxor) }, /* 0xb6 D^P^(S|(D&P)) */
342 { OP(PAT,DST,GXxor), OP(SRC,DST,GXnand) }, /* 0xb7 ~(S&(D^P)) */
343 { OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
344 OP(PAT,DST,GXxor) }, /* 0xb8 P^(S&(D^P)) */
345 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
346 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0xb9 ~D^(S|(P&D)) */
347 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXor) }, /* 0xba D|(P&~S) */
348 { OP(SRC,DST,GXorInverted) }, /* 0xbb ~S|D */
349 { OP(SRC,DST,GXnand), OP(PAT,DST,GXand),
350 OP(SRC,DST,GXxor) }, /* 0xbc S^(P&~(D&S)) */
351 { OP(DST,SRC,GXxor), OP(PAT,DST,GXxor),
352 OP(SRC,DST,GXnand) }, /* 0xbd ~((S^D)&(P^D)) */
353 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXor) }, /* 0xbe D|(P^S) */
354 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXor) }, /* 0xbf D|~(P&S) */
355 { OP(PAT,SRC,GXand) }, /* 0xc0 P&S */
356 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXor),
357 OP(SRC,DST,GXequiv) }, /* 0xc1 ~S^(P|(D&~S)) */
358 { OP(SRC,DST,GXnor), OP(PAT,DST,GXor),
359 OP(SRC,DST,GXequiv) }, /* 0xc2 ~S^(P|~(D|S)) */
360 { OP(PAT,SRC,GXequiv) }, /* 0xc3 ~P^S */
361 { OP(PAT,DST,GXorReverse), OP(SRC,DST,GXand) }, /* 0xc4 S&(P|~D) */
362 { OP(SRC,DST,GXxor), OP(PAT,DST,GXor),
363 OP(SRC,DST,GXequiv) }, /* 0xc5 ~S^(P|(D^S)) */
364 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXxor) },/* 0xc6 S^(D&~P) */
365 { OP(PAT,DST,GXor), OP(SRC,DST,GXand),
366 OP(PAT,DST,GXequiv) }, /* 0xc7 ~P^(S&(D|P)) */
367 { OP(PAT,DST,GXor), OP(SRC,DST,GXand) }, /* 0xc8 S&(D|P) */
368 { OP(PAT,DST,GXor), OP(SRC,DST,GXequiv) }, /* 0xc9 ~S^(P|D) */
369 { OP(DST,SRC,GXxor), OP(PAT,SRC,GXand),
370 OP(SRC,DST,GXxor) }, /* 0xca D^(P&(S^D)) */
371 { OP(SRC,DST,GXand), OP(PAT,DST,GXor),
372 OP(SRC,DST,GXequiv) }, /* 0xcb ~S^(P|(D&S)) */
373 { OP(SRC,DST,GXcopy) }, /* 0xcc S */
374 { OP(PAT,DST,GXnor), OP(SRC,DST,GXor) }, /* 0xcd S|~(D|P) */
375 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXor) }, /* 0xce S|(D&~P) */
376 { OP(PAT,SRC,GXorInverted) }, /* 0xcf S|~P */
377 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXand) }, /* 0xd0 P&(S|~D) */
378 { OP(PAT,DST,GXxor), OP(SRC,DST,GXor),
379 OP(PAT,DST,GXequiv) }, /* 0xd1 ~P^(S|(D^P)) */
380 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXxor) },/* 0xd2 P^(D&~S) */
381 { OP(SRC,DST,GXor), OP(PAT,DST,GXand),
382 OP(SRC,DST,GXequiv) }, /* 0xd3 ~S^(P&(D|S)) */
383 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
384 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
385 OP(TMP,DST,GXxor) }, /* 0xd4 S^((S^P)&(D^P))*/
386 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXnand) }, /* 0xd5 ~(D&~(P&S)) */
387 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXand),
388 OP(SRC,DST,GXor), OP(PAT,DST,GXxor),
389 OP(TMP,DST,GXxor) }, /* 0xd6 S^P^(D|(P&S)) */
390 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXnand) }, /* 0xd7 ~(D&(P^S)) */
391 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXand),
392 OP(PAT,DST,GXxor) }, /* 0xd8 P^(D&(S^P)) */
393 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXand),
394 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0xd9 ~S^(D|(P&S)) */
395 { OP(DST,SRC,GXnand), OP(PAT,SRC,GXand),
396 OP(SRC,DST,GXxor) }, /* 0xda D^(P&~(S&D)) */
397 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
398 OP(SRC,DST,GXnand) }, /* 0xdb ~((S^P)&(S^D)) */
399 { OP(PAT,DST,GXandReverse), OP(SRC,DST,GXor) }, /* 0xdc S|(P&~D) */
400 { OP(SRC,DST,GXorReverse) }, /* 0xdd S|~D */
401 { OP(PAT,DST,GXxor), OP(SRC,DST,GXor) }, /* 0xde S|(D^P) */
402 { OP(PAT,DST,GXnand), OP(SRC,DST,GXor) }, /* 0xdf S|~(D&P) */
403 { OP(SRC,DST,GXor), OP(PAT,DST,GXand) }, /* 0xe0 P&(D|S) */
404 { OP(SRC,DST,GXor), OP(PAT,DST,GXequiv) }, /* 0xe1 ~P^(D|S) */
405 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
406 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0xe2 D^(S&(P^D)) */
407 { OP(PAT,DST,GXand), OP(SRC,DST,GXor),
408 OP(PAT,DST,GXequiv) }, /* 0xe3 ~P^(S|(D&P)) */
409 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
410 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0xe4 S^(D&(P^S)) */
411 { OP(PAT,SRC,GXand), OP(SRC,DST,GXor),
412 OP(PAT,DST,GXequiv) }, /* 0xe5 ~P^(D|(S&P)) */
413 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnand),
414 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0xe6 S^(D&~(P&S)) */
415 { OP(PAT,SRC,GXxor), OP(PAT,DST,GXxor),
416 OP(SRC,DST,GXnand) }, /* 0xe7 ~((S^P)&(D^P)) */
417 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
418 OP(PAT,SRC,GXxor), OP(SRC,DST,GXand),
419 OP(TMP,DST,GXxor) }, /* 0xe8 S^((S^P)&(S^D))*/
420 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXnand),
421 OP(PAT,DST,GXand), OP(SRC,DST,GXxor),
422 OP(TMP,DST,GXequiv) }, /* 0xe9 ~D^S^(P&~(S&D))*/
423 { OP(PAT,SRC,GXand), OP(SRC,DST,GXor) }, /* 0xea D|(P&S) */
424 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXor) }, /* 0xeb D|~(P^S) */
425 { OP(PAT,DST,GXand), OP(SRC,DST,GXor) }, /* 0xec S|(D&P) */
426 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXor) }, /* 0xed S|~(D^P) */
427 { OP(SRC,DST,GXor) }, /* 0xee S|D */
428 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXor) }, /* 0xef S|D|~P */
429 { OP(PAT,DST,GXcopy) }, /* 0xf0 P */
430 { OP(SRC,DST,GXnor), OP(PAT,DST,GXor) }, /* 0xf1 P|~(D|S) */
431 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXor) }, /* 0xf2 P|(D&~S) */
432 { OP(PAT,SRC,GXorReverse) }, /* 0xf3 P|~S */
433 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXor) }, /* 0xf4 P|(S&~D) */
434 { OP(PAT,DST,GXorReverse) }, /* 0xf5 P|~D */
435 { OP(SRC,DST,GXxor), OP(PAT,DST,GXor) }, /* 0xf6 P|(D^S) */
436 { OP(SRC,DST,GXnand), OP(PAT,DST,GXor) }, /* 0xf7 P|~(S&D) */
437 { OP(SRC,DST,GXand), OP(PAT,DST,GXor) }, /* 0xf8 P|(D&S) */
438 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXor) }, /* 0xf9 P|~(D^S) */
439 { OP(PAT,DST,GXor) }, /* 0xfa D|P */
440 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXor) }, /* 0xfb D|P|~S */
441 { OP(PAT,SRC,GXor) }, /* 0xfc P|S */
442 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXor) }, /* 0xfd P|S|~D */
443 { OP(SRC,DST,GXor), OP(PAT,DST,GXor) }, /* 0xfe P|D|S */
444 { OP(PAT,DST,GXset) } /* 0xff 1 */
445 };
446
447 static const unsigned char bit_swap[256] =
448 {
449 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
450 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
451 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
452 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
453 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
454 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
455 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
456 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
457 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
458 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
459 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
460 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
461 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
462 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
463 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
464 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
465 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
466 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
467 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
468 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
469 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
470 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
471 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
472 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
473 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
474 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
475 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
476 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
477 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
478 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
479 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
480 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
481 };
482
483 #ifdef WORDS_BIGENDIAN
484 static const unsigned int zeropad_masks[32] =
485 {
486 0xffffffff, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000, 0xfc000000, 0xfe000000,
487 0xff000000, 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000,
488 0xffff0000, 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
489 0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 0xfffffff8, 0xfffffffc, 0xfffffffe
490 };
491 #else
492 static const unsigned int zeropad_masks[32] =
493 {
494 0xffffffff, 0x00000080, 0x000000c0, 0x000000e0, 0x000000f0, 0x000000f8, 0x000000fc, 0x000000fe,
495 0x000000ff, 0x000080ff, 0x0000c0ff, 0x0000e0ff, 0x0000f0ff, 0x0000f8ff, 0x0000fcff, 0x0000feff,
496 0x0000ffff, 0x0080ffff, 0x00c0ffff, 0x00e0ffff, 0x00f0ffff, 0x00f8ffff, 0x00fcffff, 0x00feffff,
497 0x00ffffff, 0x80ffffff, 0xc0ffffff, 0xe0ffffff, 0xf0ffffff, 0xf8ffffff, 0xfcffffff, 0xfeffffff
498 };
499 #endif
500
501 #ifdef BITBLT_TEST /* Opcodes test */
502
503 static int do_bitop( int s, int d, int rop )
504 {
505 int res;
506 switch(rop)
507 {
508 case GXclear: res = 0; break;
509 case GXand: res = s & d; break;
510 case GXandReverse: res = s & ~d; break;
511 case GXcopy: res = s; break;
512 case GXandInverted: res = ~s & d; break;
513 case GXnoop: res = d; break;
514 case GXxor: res = s ^ d; break;
515 case GXor: res = s | d; break;
516 case GXnor: res = ~(s | d); break;
517 case GXequiv: res = ~s ^ d; break;
518 case GXinvert: res = ~d; break;
519 case GXorReverse: res = s | ~d; break;
520 case GXcopyInverted: res = ~s; break;
521 case GXorInverted: res = ~s | d; break;
522 case GXnand: res = ~(s & d); break;
523 case GXset: res = 1; break;
524 }
525 return res & 1;
526 }
527
528 int main()
529 {
530 int rop, i, res, src, dst, pat, tmp, dstUsed;
531 const unsigned char *opcode;
532
533 for (rop = 0; rop < 256; rop++)
534 {
535 res = dstUsed = 0;
536 for (i = 0; i < 8; i++)
537 {
538 pat = (i >> 2) & 1;
539 src = (i >> 1) & 1;
540 dst = i & 1;
541 for (opcode = BITBLT_Opcodes[rop]; *opcode; opcode++)
542 {
543 switch(*opcode >> 4)
544 {
545 case OP_ARGS(DST,TMP):
546 tmp = do_bitop( dst, tmp, *opcode & 0xf );
547 break;
548 case OP_ARGS(DST,SRC):
549 src = do_bitop( dst, src, *opcode & 0xf );
550 break;
551 case OP_ARGS(SRC,TMP):
552 tmp = do_bitop( src, tmp, *opcode & 0xf );
553 break;
554 case OP_ARGS(SRC,DST):
555 dst = do_bitop( src, dst, *opcode & 0xf );
556 dstUsed = 1;
557 break;
558 case OP_ARGS(PAT,DST):
559 dst = do_bitop( pat, dst, *opcode & 0xf );
560 dstUsed = 1;
561 break;
562 case OP_ARGS(PAT,SRC):
563 src = do_bitop( pat, src, *opcode & 0xf );
564 break;
565 case OP_ARGS(TMP,DST):
566 dst = do_bitop( tmp, dst, *opcode & 0xf );
567 dstUsed = 1;
568 break;
569 case OP_ARGS(TMP,SRC):
570 src = do_bitop( tmp, src, *opcode & 0xf );
571 break;
572 default:
573 printf( "Invalid opcode %x\n", *opcode );
574 }
575 }
576 if (!dstUsed) dst = src;
577 if (dst) res |= 1 << i;
578 }
579 if (res != rop) printf( "%02x: ERROR, res=%02x\n", rop, res );
580 }
581
582 return 0;
583 }
584
585 #endif /* BITBLT_TEST */
586
587
588 static void get_colors(X11DRV_PDEVICE *physDevDst, X11DRV_PDEVICE *physDevSrc,
589 int *fg, int *bg)
590 {
591 RGBQUAD rgb[2];
592
593 *fg = physDevDst->textPixel;
594 *bg = physDevDst->backgroundPixel;
595 if(physDevSrc->depth == 1) {
596 if(GetDIBColorTable(physDevSrc->dev.hdc, 0, 2, rgb) == 2) {
597 DWORD logcolor;
598 logcolor = RGB(rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue);
599 *fg = X11DRV_PALETTE_ToPhysical( physDevDst, logcolor );
600 logcolor = RGB(rgb[1].rgbRed, rgb[1].rgbGreen,rgb[1].rgbBlue);
601 *bg = X11DRV_PALETTE_ToPhysical( physDevDst, logcolor );
602 }
603 }
604 }
605
606 /* return a mask for meaningful bits when doing an XGetPixel on an image */
607 static unsigned long image_pixel_mask( X11DRV_PDEVICE *physDev )
608 {
609 unsigned long ret;
610 ColorShifts *shifts = physDev->color_shifts;
611
612 if (!shifts) shifts = &X11DRV_PALETTE_default_shifts;
613 ret = (shifts->physicalRed.max << shifts->physicalRed.shift) |
614 (shifts->physicalGreen.max << shifts->physicalGreen.shift) |
615 (shifts->physicalBlue.max << shifts->physicalBlue.shift);
616 if (!ret) ret = (1 << physDev->depth) - 1;
617 return ret;
618 }
619
620
621 /***********************************************************************
622 * BITBLT_StretchRow
623 *
624 * Stretch a row of pixels. Helper function for BITBLT_StretchImage.
625 */
626 static void BITBLT_StretchRow( int *rowSrc, int *rowDst,
627 INT startDst, INT widthDst,
628 INT xinc, INT xoff, WORD mode )
629 {
630 register INT xsrc = xinc * startDst + xoff;
631 rowDst += startDst;
632 switch(mode)
633 {
634 case STRETCH_ANDSCANS:
635 for(; widthDst > 0; widthDst--, xsrc += xinc)
636 *rowDst++ &= rowSrc[xsrc >> 16];
637 break;
638 case STRETCH_ORSCANS:
639 for(; widthDst > 0; widthDst--, xsrc += xinc)
640 *rowDst++ |= rowSrc[xsrc >> 16];
641 break;
642 case STRETCH_DELETESCANS:
643 for(; widthDst > 0; widthDst--, xsrc += xinc)
644 *rowDst++ = rowSrc[xsrc >> 16];
645 break;
646 }
647 }
648
649
650 /***********************************************************************
651 * BITBLT_ShrinkRow
652 *
653 * Shrink a row of pixels. Helper function for BITBLT_StretchImage.
654 */
655 static void BITBLT_ShrinkRow( int *rowSrc, int *rowDst,
656 INT startSrc, INT widthSrc,
657 INT xinc, INT xoff, WORD mode )
658 {
659 register INT xdst = xinc * startSrc + xoff;
660 rowSrc += startSrc;
661 switch(mode)
662 {
663 case STRETCH_ORSCANS:
664 for(; widthSrc > 0; widthSrc--, xdst += xinc)
665 rowDst[xdst >> 16] |= *rowSrc++;
666 break;
667 case STRETCH_ANDSCANS:
668 for(; widthSrc > 0; widthSrc--, xdst += xinc)
669 rowDst[xdst >> 16] &= *rowSrc++;
670 break;
671 case STRETCH_DELETESCANS:
672 for(; widthSrc > 0; widthSrc--, xdst += xinc)
673 rowDst[xdst >> 16] = *rowSrc++;
674 break;
675 }
676 }
677
678
679 /***********************************************************************
680 * BITBLT_GetRow
681 *
682 * Retrieve a row from an image. Helper function for BITBLT_StretchImage.
683 */
684 static void BITBLT_GetRow( XImage *image, int *pdata, INT row,
685 INT start, INT width, INT depthDst,
686 int fg, int bg, unsigned long pixel_mask, BOOL swap)
687 {
688 register INT i;
689
690 assert( (row >= 0) && (row < image->height) );
691 assert( (start >= 0) && (width <= image->width) );
692
693 pdata += swap ? start+width-1 : start;
694 if (image->depth == depthDst) /* color -> color */
695 {
696 if (X11DRV_PALETTE_XPixelToPalette && (depthDst != 1))
697 if (swap) for (i = 0; i < width; i++)
698 *pdata-- = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )];
699 else for (i = 0; i < width; i++)
700 *pdata++ = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )];
701 else
702 if (swap) for (i = 0; i < width; i++)
703 *pdata-- = XGetPixel( image, i, row );
704 else for (i = 0; i < width; i++)
705 *pdata++ = XGetPixel( image, i, row );
706 }
707 else
708 {
709 if (image->depth == 1) /* monochrome -> color */
710 {
711 if (X11DRV_PALETTE_XPixelToPalette)
712 {
713 fg = X11DRV_PALETTE_XPixelToPalette[fg];
714 bg = X11DRV_PALETTE_XPixelToPalette[bg];
715 }
716 if (swap) for (i = 0; i < width; i++)
717 *pdata-- = XGetPixel( image, i, row ) ? bg : fg;
718 else for (i = 0; i < width; i++)
719 *pdata++ = XGetPixel( image, i, row ) ? bg : fg;
720 }
721 else /* color -> monochrome */
722 {
723 if (swap) for (i = 0; i < width; i++)
724 *pdata-- = ((XGetPixel( image, i, row ) & pixel_mask) == bg) ? 1 : 0;
725 else for (i = 0; i < width; i++)
726 *pdata++ = ((XGetPixel( image, i, row ) & pixel_mask) == bg) ? 1 : 0;
727 }
728 }
729 }
730
731
732 /***********************************************************************
733 * BITBLT_StretchImage
734 *
735 * Stretch an X image.
736 * FIXME: does not work for full 32-bit coordinates.
737 */
738 static void BITBLT_StretchImage( XImage *srcImage, XImage *dstImage,
739 INT widthSrc, INT heightSrc,
740 INT widthDst, INT heightDst,
741 RECT *visRectSrc, RECT *visRectDst,
742 int foreground, int background,
743 unsigned long pixel_mask, WORD mode )
744 {
745 int *rowSrc, *rowDst, *pixel;
746 char *pdata;
747 INT xinc, xoff, yinc, ysrc, ydst;
748 register INT x, y;
749 BOOL hstretch, vstretch, hswap, vswap;
750
751 hswap = widthSrc * widthDst < 0;
752 vswap = heightSrc * heightDst < 0;
753 widthSrc = abs(widthSrc);
754 heightSrc = abs(heightSrc);
755 widthDst = abs(widthDst);
756 heightDst = abs(heightDst);
757
758 if (!(rowSrc = HeapAlloc( GetProcessHeap(), 0,
759 (widthSrc+widthDst)*sizeof(int) ))) return;
760 rowDst = rowSrc + widthSrc;
761
762 /* When stretching, all modes are the same, and DELETESCANS is faster */
763 if ((widthSrc < widthDst) && (heightSrc < heightDst))
764 mode = STRETCH_DELETESCANS;
765
766 if (mode == STRETCH_HALFTONE) /* FIXME */
767 mode = STRETCH_DELETESCANS;
768
769 if (mode != STRETCH_DELETESCANS)
770 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
771 widthDst*sizeof(int) );
772
773 hstretch = (widthSrc < widthDst);
774 vstretch = (heightSrc < heightDst);
775
776 if (hstretch)
777 {
778 xinc = (widthSrc << 16) / widthDst;
779 xoff = ((widthSrc << 16) - (xinc * widthDst)) / 2;
780 }
781 else
782 {
783 xinc = ((int)widthDst << 16) / widthSrc;
784 xoff = ((widthDst << 16) - (xinc * widthSrc)) / 2;
785 }
786
787 wine_tsx11_lock();
788 if (vstretch)
789 {
790 yinc = (heightSrc << 16) / heightDst;
791 ydst = visRectDst->top;
792 if (vswap)
793 {
794 ysrc = yinc * (heightDst - ydst - 1);
795 yinc = -yinc;
796 }
797 else
798 ysrc = yinc * ydst;
799
800 for ( ; (ydst < visRectDst->bottom); ysrc += yinc, ydst++)
801 {
802 if (((ysrc >> 16) < visRectSrc->top) ||
803 ((ysrc >> 16) >= visRectSrc->bottom)) continue;
804
805 /* Retrieve a source row */
806 BITBLT_GetRow( srcImage, rowSrc, (ysrc >> 16) - visRectSrc->top,
807 visRectSrc->left, visRectSrc->right - visRectSrc->left,
808 dstImage->depth, foreground, background, pixel_mask, hswap );
809
810 /* Stretch or shrink it */
811 if (hstretch)
812 BITBLT_StretchRow( rowSrc, rowDst, visRectDst->left,
813 visRectDst->right - visRectDst->left,
814 xinc, xoff, mode );
815 else BITBLT_ShrinkRow( rowSrc, rowDst, visRectSrc->left,
816 visRectSrc->right - visRectSrc->left,
817 xinc, xoff, mode );
818
819 /* Store the destination row */
820 pixel = rowDst + visRectDst->right - 1;
821 y = ydst - visRectDst->top;
822 for (x = visRectDst->right-visRectDst->left-1; x >= 0; x--)
823 XPutPixel( dstImage, x, y, *pixel-- );
824 if (mode != STRETCH_DELETESCANS)
825 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
826 widthDst*sizeof(int) );
827
828 /* Make copies of the destination row */
829
830 pdata = dstImage->data + dstImage->bytes_per_line * y;
831 while (((ysrc + yinc) >> 16 == ysrc >> 16) &&
832 (ydst < visRectDst->bottom-1))
833 {
834 memcpy( pdata + dstImage->bytes_per_line, pdata,
835 dstImage->bytes_per_line );
836 pdata += dstImage->bytes_per_line;
837 ysrc += yinc;
838 ydst++;
839 }
840 }
841 }
842 else /* Shrinking */
843 {
844 yinc = (heightDst << 16) / heightSrc;
845 ysrc = visRectSrc->top;
846 ydst = ((heightDst << 16) - (yinc * heightSrc)) / 2;
847 if (vswap)
848 {
849 ydst += yinc * (heightSrc - ysrc - 1);
850 yinc = -yinc;
851 }
852 else
853 ydst += yinc * ysrc;
854
855 for( ; (ysrc < visRectSrc->bottom); ydst += yinc, ysrc++)
856 {
857 if (((ydst >> 16) < visRectDst->top) ||
858 ((ydst >> 16) >= visRectDst->bottom)) continue;
859
860 /* Retrieve a source row */
861 BITBLT_GetRow( srcImage, rowSrc, ysrc - visRectSrc->top,
862 visRectSrc->left, visRectSrc->right - visRectSrc->left,
863 dstImage->depth, foreground, background, pixel_mask, hswap );
864
865 /* Stretch or shrink it */
866 if (hstretch)
867 BITBLT_StretchRow( rowSrc, rowDst, visRectDst->left,
868 visRectDst->right - visRectDst->left,
869 xinc, xoff, mode );
870 else BITBLT_ShrinkRow( rowSrc, rowDst, visRectSrc->left,
871 visRectSrc->right - visRectSrc->left,
872 xinc, xoff, mode );
873
874 /* Merge several source rows into the destination */
875 if (mode == STRETCH_DELETESCANS)
876 {
877 /* Simply skip the overlapping rows */
878 while (((ydst + yinc) >> 16 == ydst >> 16) &&
879 (ysrc < visRectSrc->bottom-1))
880 {
881 ydst += yinc;
882 ysrc++;
883 }
884 }
885 else if (((ydst + yinc) >> 16 == ydst >> 16) &&
886 (ysrc < visRectSrc->bottom-1))
887 continue; /* Restart loop for next overlapping row */
888
889 /* Store the destination row */
890 pixel = rowDst + visRectDst->right - 1;
891 y = (ydst >> 16) - visRectDst->top;
892 for (x = visRectDst->right-visRectDst->left-1; x >= 0; x--)
893 XPutPixel( dstImage, x, y, *pixel-- );
894 if (mode != STRETCH_DELETESCANS)
895 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
896 widthDst*sizeof(int) );
897 }
898 }
899 wine_tsx11_unlock();
900 HeapFree( GetProcessHeap(), 0, rowSrc );
901 }
902
903
904 /***********************************************************************
905 * BITBLT_GetSrcAreaStretch
906 *
907 * Retrieve an area from the source DC, stretching and mapping all the
908 * pixels to Windows colors.
909 */
910 static int BITBLT_GetSrcAreaStretch( X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
911 Pixmap pixmap, GC gc,
912 const struct bitblt_coords *src, const struct bitblt_coords *dst )
913 {
914 XImage *imageSrc, *imageDst;
915 RECT rectSrc = src->visrect;
916 RECT rectDst = dst->visrect;
917 int fg, bg;
918
919 rectSrc.left -= src->x;
920 rectSrc.right -= src->x;
921 rectSrc.top -= src->y;
922 rectSrc.bottom -= src->y;
923 rectDst.left -= dst->x;
924 rectDst.right -= dst->x;
925 rectDst.top -= dst->y;
926 rectDst.bottom -= dst->y;
927 if (src->width < 0)
928 {
929 rectSrc.left -= src->width;
930 rectSrc.right -= src->width;
931 }
932 if (dst->width < 0)
933 {
934 rectDst.left -= dst->width;
935 rectDst.right -= dst->width;
936 }
937 if (src->height < 0)
938 {
939 rectSrc.top -= src->height;
940 rectSrc.bottom -= src->height;
941 }
942 if (dst->height < 0)
943 {
944 rectDst.top -= dst->height;
945 rectDst.bottom -= dst->height;
946 }
947
948 get_colors(physDevDst, physDevSrc, &fg, &bg);
949 wine_tsx11_lock();
950 /* FIXME: avoid BadMatch errors */
951 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
952 physDevSrc->dc_rect.left + src->visrect.left,
953 physDevSrc->dc_rect.top + src->visrect.top,
954 src->visrect.right - src->visrect.left,
955 src->visrect.bottom - src->visrect.top,
956 AllPlanes, ZPixmap );
957 wine_tsx11_unlock();
958
959 imageDst = X11DRV_DIB_CreateXImage( rectDst.right - rectDst.left,
960 rectDst.bottom - rectDst.top, physDevDst->depth );
961 BITBLT_StretchImage( imageSrc, imageDst, src->width, src->height,
962 dst->width, dst->height, &rectSrc, &rectDst,
963 fg, physDevDst->depth != 1 ? bg : physDevSrc->backgroundPixel,
964 image_pixel_mask( physDevSrc ), GetStretchBltMode(physDevDst->dev.hdc) );
965 wine_tsx11_lock();
966 XPutImage( gdi_display, pixmap, gc, imageDst, 0, 0, 0, 0,
967 rectDst.right - rectDst.left, rectDst.bottom - rectDst.top );
968 XDestroyImage( imageSrc );
969 X11DRV_DIB_DestroyXImage( imageDst );
970 wine_tsx11_unlock();
971 return 0; /* no exposure events generated */
972 }
973
974
975 /***********************************************************************
976 * BITBLT_GetSrcArea
977 *
978 * Retrieve an area from the source DC, mapping all the
979 * pixels to Windows colors.
980 */
981 static int BITBLT_GetSrcArea( X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
982 Pixmap pixmap, GC gc, RECT *visRectSrc )
983 {
984 XImage *imageSrc, *imageDst;
985 register INT x, y;
986 int exposures = 0;
987 INT width = visRectSrc->right - visRectSrc->left;
988 INT height = visRectSrc->bottom - visRectSrc->top;
989 int fg, bg;
990 BOOL memdc = (GetObjectType(physDevSrc->dev.hdc) == OBJ_MEMDC);
991
992 if (physDevSrc->depth == physDevDst->depth)
993 {
994 wine_tsx11_lock();
995 if (!X11DRV_PALETTE_XPixelToPalette ||
996 (physDevDst->depth == 1)) /* monochrome -> monochrome */
997 {
998 if (physDevDst->depth == 1)
999 {
1000 /* MSDN says if StretchBlt must convert a bitmap from monochrome
1001 to color or vice versa, the foreground and background color of
1002 the device context are used. In fact, it also applies to the
1003 case when it is converted from mono to mono. */
1004 XSetBackground( gdi_display, gc, physDevDst->textPixel );
1005 XSetForeground( gdi_display, gc, physDevDst->backgroundPixel );
1006 XCopyPlane( gdi_display, physDevSrc->drawable, pixmap, gc,
1007 physDevSrc->dc_rect.left + visRectSrc->left,
1008 physDevSrc->dc_rect.top + visRectSrc->top,
1009 width, height, 0, 0, 1);
1010 }
1011 else
1012 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc,
1013 physDevSrc->dc_rect.left + visRectSrc->left,
1014 physDevSrc->dc_rect.top + visRectSrc->top,
1015 width, height, 0, 0);
1016 exposures++;
1017 }
1018 else /* color -> color */
1019 {
1020 if (memdc)
1021 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
1022 physDevSrc->dc_rect.left + visRectSrc->left,
1023 physDevSrc->dc_rect.top + visRectSrc->top,
1024 width, height, AllPlanes, ZPixmap );
1025 else
1026 {
1027 /* Make sure we don't get a BadMatch error */
1028 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc,
1029 physDevSrc->dc_rect.left + visRectSrc->left,
1030 physDevSrc->dc_rect.top + visRectSrc->top,
1031 width, height, 0, 0);
1032 exposures++;
1033 imageSrc = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1034 AllPlanes, ZPixmap );
1035 }
1036 for (y = 0; y < height; y++)
1037 for (x = 0; x < width; x++)
1038 XPutPixel(imageSrc, x, y,
1039 X11DRV_PALETTE_XPixelToPalette[XGetPixel(imageSrc, x, y)]);
1040 XPutImage( gdi_display, pixmap, gc, imageSrc,
1041 0, 0, 0, 0, width, height );
1042 XDestroyImage( imageSrc );
1043 }
1044 wine_tsx11_unlock();
1045 }
1046 else
1047 {
1048 if (physDevSrc->depth == 1) /* monochrome -> color */
1049 {
1050 get_colors(physDevDst, physDevSrc, &fg, &bg);
1051
1052 wine_tsx11_lock();
1053 if (X11DRV_PALETTE_XPixelToPalette)
1054 {
1055 XSetBackground( gdi_display, gc,
1056 X11DRV_PALETTE_XPixelToPalette[fg] );
1057 XSetForeground( gdi_display, gc,
1058 X11DRV_PALETTE_XPixelToPalette[bg]);
1059 }
1060 else
1061 {
1062 XSetBackground( gdi_display, gc, fg );
1063 XSetForeground( gdi_display, gc, bg );
1064 }
1065 XCopyPlane( gdi_display, physDevSrc->drawable, pixmap, gc,
1066 physDevSrc->dc_rect.left + visRectSrc->left,
1067 physDevSrc->dc_rect.top + visRectSrc->top,
1068 width, height, 0, 0, 1 );
1069 exposures++;
1070 wine_tsx11_unlock();
1071 }
1072 else /* color -> monochrome */
1073 {
1074 unsigned long pixel_mask;
1075 wine_tsx11_lock();
1076 /* FIXME: avoid BadMatch error */
1077 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
1078 physDevSrc->dc_rect.left + visRectSrc->left,
1079 physDevSrc->dc_rect.top + visRectSrc->top,
1080 width, height, AllPlanes, ZPixmap );
1081 if (!imageSrc)
1082 {
1083 wine_tsx11_unlock();
1084 return exposures;
1085 }
1086 imageDst = X11DRV_DIB_CreateXImage( width, height, physDevDst->depth );
1087 if (!imageDst)
1088 {
1089 XDestroyImage(imageSrc);
1090 wine_tsx11_unlock();
1091 return exposures;
1092 }
1093 pixel_mask = image_pixel_mask( physDevSrc );
1094 for (y = 0; y < height; y++)
1095 for (x = 0; x < width; x++)
1096 XPutPixel(imageDst, x, y,
1097 !((XGetPixel(imageSrc,x,y) ^ physDevSrc->backgroundPixel) & pixel_mask));
1098 XPutImage( gdi_display, pixmap, gc, imageDst,
1099 0, 0, 0, 0, width, height );
1100 XDestroyImage( imageSrc );
1101 X11DRV_DIB_DestroyXImage( imageDst );
1102 wine_tsx11_unlock();
1103 }
1104 }
1105 return exposures;
1106 }
1107
1108
1109 /***********************************************************************
1110 * BITBLT_GetDstArea
1111 *
1112 * Retrieve an area from the destination DC, mapping all the
1113 * pixels to Windows colors.
1114 */
1115 static int BITBLT_GetDstArea(X11DRV_PDEVICE *physDev, Pixmap pixmap, GC gc, const RECT *visRectDst)
1116 {
1117 int exposures = 0;
1118 INT width = visRectDst->right - visRectDst->left;
1119 INT height = visRectDst->bottom - visRectDst->top;
1120 BOOL memdc = (GetObjectType( physDev->dev.hdc ) == OBJ_MEMDC);
1121
1122 wine_tsx11_lock();
1123
1124 if (!X11DRV_PALETTE_XPixelToPalette || (physDev->depth == 1) ||
1125 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) )
1126 {
1127 XCopyArea( gdi_display, physDev->drawable, pixmap, gc,
1128 physDev->dc_rect.left + visRectDst->left, physDev->dc_rect.top + visRectDst->top,
1129 width, height, 0, 0 );
1130 exposures++;
1131 }
1132 else
1133 {
1134 register INT x, y;
1135 XImage *image;
1136
1137 if (memdc)
1138 image = XGetImage( gdi_display, physDev->drawable,
1139 physDev->dc_rect.left + visRectDst->left,
1140 physDev->dc_rect.top + visRectDst->top,
1141 width, height, AllPlanes, ZPixmap );
1142 else
1143 {
1144 /* Make sure we don't get a BadMatch error */
1145 XCopyArea( gdi_display, physDev->drawable, pixmap, gc,
1146 physDev->dc_rect.left + visRectDst->left,
1147 physDev->dc_rect.top + visRectDst->top,
1148 width, height, 0, 0);
1149 exposures++;
1150 image = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1151 AllPlanes, ZPixmap );
1152 }
1153 if (image)
1154 {
1155 for (y = 0; y < height; y++)
1156 for (x = 0; x < width; x++)
1157 XPutPixel( image, x, y,
1158 X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y )]);
1159 XPutImage( gdi_display, pixmap, gc, image, 0, 0, 0, 0, width, height );
1160 XDestroyImage( image );
1161 }
1162 }
1163
1164 wine_tsx11_unlock();
1165 return exposures;
1166 }
1167
1168
1169 /***********************************************************************
1170 * BITBLT_PutDstArea
1171 *
1172 * Put an area back into the destination DC, mapping the pixel
1173 * colors to X pixels.
1174 */
1175 static int BITBLT_PutDstArea(X11DRV_PDEVICE *physDev, Pixmap pixmap, const RECT *visRectDst)
1176 {
1177 int exposures = 0;
1178 INT width = visRectDst->right - visRectDst->left;
1179 INT height = visRectDst->bottom - visRectDst->top;
1180
1181 /* !X11DRV_PALETTE_PaletteToXPixel is _NOT_ enough */
1182
1183 if (!X11DRV_PALETTE_PaletteToXPixel || (physDev->depth == 1) ||
1184 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) )
1185 {
1186 XCopyArea( gdi_display, pixmap, physDev->drawable, physDev->gc, 0, 0, width, height,
1187 physDev->dc_rect.left + visRectDst->left,
1188 physDev->dc_rect.top + visRectDst->top );
1189 exposures++;
1190 }
1191 else
1192 {
1193 register INT x, y;
1194 XImage *image = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1195 AllPlanes, ZPixmap );
1196 for (y = 0; y < height; y++)
1197 for (x = 0; x < width; x++)
1198 {
1199 XPutPixel( image, x, y,
1200 X11DRV_PALETTE_PaletteToXPixel[XGetPixel( image, x, y )]);
1201 }
1202 XPutImage( gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1203 physDev->dc_rect.left + visRectDst->left,
1204 physDev->dc_rect.top + visRectDst->top, width, height );
1205 XDestroyImage( image );
1206 }
1207 return exposures;
1208 }
1209
1210
1211 /***********************************************************************
1212 * client_side_dib_copy
1213 */
1214 static BOOL client_side_dib_copy( X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1215 X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1216 INT width, INT height )
1217 {
1218 DIBSECTION srcDib, dstDib;
1219 BYTE *srcPtr, *dstPtr;
1220 INT srcRowOffset, dstRowOffset;
1221 INT bytesPerPixel;
1222 INT bytesToCopy;
1223 INT y;
1224 static RECT unusedRect;
1225
1226 if (GetObjectW(physDevSrc->bitmap->hbitmap, sizeof(srcDib), &srcDib) != sizeof(srcDib))
1227 return FALSE;
1228 if (GetObjectW(physDevDst->bitmap->hbitmap, sizeof(dstDib), &dstDib) != sizeof(dstDib))
1229 return FALSE;
1230
1231 /* check for oversized values, just like X11DRV_DIB_CopyDIBSection() */
1232 if (xSrc > srcDib.dsBm.bmWidth || ySrc > srcDib.dsBm.bmHeight)
1233 return FALSE;
1234 if (xSrc + width > srcDib.dsBm.bmWidth)
1235 width = srcDib.dsBm.bmWidth - xSrc;
1236 if (ySrc + height > srcDib.dsBm.bmHeight)
1237 height = srcDib.dsBm.bmHeight - ySrc;
1238
1239 if (GetRgnBox(physDevDst->region, &unusedRect) == COMPLEXREGION)
1240 {
1241 /* for simple regions, the clipping was already done by BITBLT_GetVisRectangles */
1242 FIXME("potential optimization: client-side complex region clipping\n");
1243 return FALSE;
1244 }
1245 if (dstDib.dsBm.bmBitsPixel <= 8)
1246 {
1247 static BOOL fixme_once;
1248 if(!fixme_once++) FIXME("potential optimization: client-side color-index mode DIB copy\n");
1249 return FALSE;
1250 }
1251 if (!(srcDib.dsBmih.biCompression == BI_BITFIELDS &&
1252 dstDib.dsBmih.biCompression == BI_BITFIELDS &&
1253 !memcmp(srcDib.dsBitfields, dstDib.dsBitfields, 3*sizeof(DWORD)))
1254 && !(srcDib.dsBmih.biCompression == BI_RGB &&
1255 dstDib.dsBmih.biCompression == BI_RGB))
1256 {
1257 FIXME("potential optimization: client-side compressed DIB copy\n");
1258 return FALSE;
1259 }
1260 if (srcDib.dsBm.bmBitsPixel != dstDib.dsBm.bmBitsPixel)
1261 {
1262 FIXME("potential optimization: pixel format conversion\n");
1263 return FALSE;
1264 }
1265 if (srcDib.dsBmih.biWidth < 0 || dstDib.dsBmih.biWidth < 0)
1266 {
1267 FIXME("negative widths not yet implemented\n");
1268 return FALSE;
1269 }
1270
1271 switch (dstDib.dsBm.bmBitsPixel)
1272 {
1273 case 15:
1274 case 16:
1275 bytesPerPixel = 2;
1276 break;
1277 case 24:
1278 bytesPerPixel = 3;
1279 break;
1280 case 32:
1281 bytesPerPixel = 4;
1282 break;
1283 default:
1284 FIXME("don't know how to work with a depth of %d\n", physDevSrc->depth);
1285 return FALSE;
1286 }
1287
1288 bytesToCopy = width * bytesPerPixel;
1289
1290 if (physDevSrc->bitmap->topdown)
1291 {
1292 srcPtr = &physDevSrc->bitmap->base[ySrc*srcDib.dsBm.bmWidthBytes + xSrc*bytesPerPixel];
1293 srcRowOffset = srcDib.dsBm.bmWidthBytes;
1294 }
1295 else
1296 {
1297 srcPtr = &physDevSrc->bitmap->base[(srcDib.dsBm.bmHeight-ySrc-1)*srcDib.dsBm.bmWidthBytes
1298 + xSrc*bytesPerPixel];
1299 srcRowOffset = -srcDib.dsBm.bmWidthBytes;
1300 }
1301 if (physDevDst->bitmap->topdown)
1302 {
1303 dstPtr = &physDevDst->bitmap->base[yDst*dstDib.dsBm.bmWidthBytes + xDst*bytesPerPixel];
1304 dstRowOffset = dstDib.dsBm.bmWidthBytes;
1305 }
1306 else
1307 {
1308 dstPtr = &physDevDst->bitmap->base[(dstDib.dsBm.bmHeight-yDst-1)*dstDib.dsBm.bmWidthBytes
1309 + xDst*bytesPerPixel];
1310 dstRowOffset = -dstDib.dsBm.bmWidthBytes;
1311 }
1312
1313 /* Handle overlapping regions on the same DIB */
1314 if (physDevSrc == physDevDst && ySrc < yDst)
1315 {
1316 srcPtr += srcRowOffset * (height - 1);
1317 srcRowOffset = -srcRowOffset;
1318 dstPtr += dstRowOffset * (height - 1);
1319 dstRowOffset = -dstRowOffset;
1320 }
1321
1322 for (y = yDst; y < yDst + height; ++y)
1323 {
1324 memmove(dstPtr, srcPtr, bytesToCopy);
1325 srcPtr += srcRowOffset;
1326 dstPtr += dstRowOffset;
1327 }
1328
1329 return TRUE;
1330 }
1331
1332 static BOOL same_format(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst)
1333 {
1334 if (physDevSrc->depth != physDevDst->depth) return FALSE;
1335 if (!physDevSrc->color_shifts && !physDevDst->color_shifts) return TRUE;
1336 if (physDevSrc->color_shifts && physDevDst->color_shifts)
1337 return !memcmp(physDevSrc->color_shifts, physDevDst->color_shifts, sizeof(ColorShifts));
1338 return FALSE;
1339 }
1340
1341 static void execute_rop( X11DRV_PDEVICE *physdev, Pixmap src_pixmap, GC gc,
1342 const RECT *visrect, DWORD rop )
1343 {
1344 Pixmap pixmaps[3];
1345 Pixmap result = src_pixmap;
1346 BOOL null_brush;
1347 const BYTE *opcode = BITBLT_Opcodes[(rop >> 16) & 0xff];
1348 BOOL use_pat = (((rop >> 4) & 0x0f0000) != (rop & 0x0f0000));
1349 BOOL use_dst = (((rop >> 1) & 0x550000) != (rop & 0x550000));
1350 int width = visrect->right - visrect->left;
1351 int height = visrect->bottom - visrect->top;
1352
1353 pixmaps[SRC] = src_pixmap;
1354 pixmaps[TMP] = 0;
1355 wine_tsx11_lock();
1356 pixmaps[DST] = XCreatePixmap( gdi_display, root_window, width, height, physdev->depth );
1357 wine_tsx11_unlock();
1358
1359 if (use_dst) BITBLT_GetDstArea( physdev, pixmaps[DST], gc, visrect );
1360 null_brush = use_pat && !X11DRV_SetupGCForPatBlt( physdev, gc, TRUE );
1361
1362 wine_tsx11_lock();
1363 for ( ; *opcode; opcode++)
1364 {
1365 if (OP_DST(*opcode) == DST) result = pixmaps[DST];
1366 XSetFunction( gdi_display, gc, OP_ROP(*opcode) );
1367 switch(OP_SRCDST(*opcode))
1368 {
1369 case OP_ARGS(DST,TMP):
1370 case OP_ARGS(SRC,TMP):
1371 if (!pixmaps[TMP])
1372 pixmaps[TMP] = XCreatePixmap( gdi_display, root_window, width, height, physdev->depth );
1373 /* fall through */
1374 case OP_ARGS(DST,SRC):
1375 case OP_ARGS(SRC,DST):
1376 case OP_ARGS(TMP,SRC):
1377 case OP_ARGS(TMP,DST):
1378 XCopyArea( gdi_display, pixmaps[OP_SRC(*opcode)], pixmaps[OP_DST(*opcode)], gc,
1379 0, 0, width, height, 0, 0 );
1380 break;
1381 case OP_ARGS(PAT,DST):
1382 case OP_ARGS(PAT,SRC):
1383 if (!null_brush)
1384 XFillRectangle( gdi_display, pixmaps[OP_DST(*opcode)], gc, 0, 0, width, height );
1385 break;
1386 }
1387 }
1388 XSetFunction( gdi_display, physdev->gc, GXcopy );
1389 physdev->exposures += BITBLT_PutDstArea( physdev, result, visrect );
1390 XFreePixmap( gdi_display, pixmaps[DST] );
1391 if (pixmaps[TMP]) XFreePixmap( gdi_display, pixmaps[TMP] );
1392 wine_tsx11_unlock();
1393 }
1394
1395 /***********************************************************************
1396 * X11DRV_PatBlt
1397 */
1398 BOOL X11DRV_PatBlt( PHYSDEV dev, struct bitblt_coords *dst, DWORD rop )
1399 {
1400 X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
1401 BOOL usePat = (((rop >> 4) & 0x0f0000) != (rop & 0x0f0000));
1402 const BYTE *opcode = BITBLT_Opcodes[(rop >> 16) & 0xff];
1403
1404 if (usePat && !X11DRV_SetupGCForBrush( physDev )) return TRUE;
1405
1406 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1407
1408 wine_tsx11_lock();
1409 XSetFunction( gdi_display, physDev->gc, OP_ROP(*opcode) );
1410
1411 switch(rop) /* a few special cases */
1412 {
1413 case BLACKNESS: /* 0x00 */
1414 case WHITENESS: /* 0xff */
1415 if ((physDev->depth != 1) && X11DRV_PALETTE_PaletteToXPixel)
1416 {
1417 XSetFunction( gdi_display, physDev->gc, GXcopy );
1418 if (rop == BLACKNESS)
1419 XSetForeground( gdi_display, physDev->gc, X11DRV_PALETTE_PaletteToXPixel[0] );
1420 else
1421 XSetForeground( gdi_display, physDev->gc,
1422 WhitePixel( gdi_display, DefaultScreen(gdi_display) ));
1423 XSetFillStyle( gdi_display, physDev->gc, FillSolid );
1424 }
1425 break;
1426 case DSTINVERT: /* 0x55 */
1427 if (!(X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_PRIVATE | X11DRV_PALETTE_VIRTUAL)))
1428 {
1429 /* Xor is much better when we do not have full colormap. */
1430 /* Using white^black ensures that we invert at least black */
1431 /* and white. */
1432 unsigned long xor_pix = (WhitePixel( gdi_display, DefaultScreen(gdi_display) ) ^
1433 BlackPixel( gdi_display, DefaultScreen(gdi_display) ));
1434 XSetFunction( gdi_display, physDev->gc, GXxor );
1435 XSetForeground( gdi_display, physDev->gc, xor_pix);
1436 XSetFillStyle( gdi_display, physDev->gc, FillSolid );
1437 }
1438 break;
1439 }
1440 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1441 physDev->dc_rect.left + dst->visrect.left,
1442 physDev->dc_rect.top + dst->visrect.top,
1443 dst->visrect.right - dst->visrect.left,
1444 dst->visrect.bottom - dst->visrect.top );
1445 wine_tsx11_unlock();
1446
1447 X11DRV_UnlockDIBSection( physDev, TRUE );
1448 return TRUE;
1449 }
1450
1451
1452 /***********************************************************************
1453 * X11DRV_StretchBlt
1454 */
1455 BOOL X11DRV_StretchBlt( PHYSDEV dst_dev, struct bitblt_coords *dst,
1456 PHYSDEV src_dev, struct bitblt_coords *src, DWORD rop )
1457 {
1458 X11DRV_PDEVICE *physDevDst = get_x11drv_dev( dst_dev );
1459 X11DRV_PDEVICE *physDevSrc = get_x11drv_dev( src_dev ); /* FIXME: check that it's really an x11 dev */
1460 BOOL fStretch;
1461 INT width, height;
1462 INT sDst, sSrc = DIB_Status_None;
1463 const BYTE *opcode;
1464 Pixmap src_pixmap;
1465 GC tmpGC;
1466
1467 fStretch = (src->width != dst->width) || (src->height != dst->height);
1468
1469 if (physDevDst != physDevSrc)
1470 sSrc = X11DRV_LockDIBSection( physDevSrc, DIB_Status_None );
1471
1472 width = dst->visrect.right - dst->visrect.left;
1473 height = dst->visrect.bottom - dst->visrect.top;
1474
1475 sDst = X11DRV_LockDIBSection( physDevDst, DIB_Status_None );
1476 if (physDevDst == physDevSrc) sSrc = sDst;
1477
1478 /* try client-side DIB copy */
1479 if (!fStretch && rop == SRCCOPY &&
1480 sSrc == DIB_Status_AppMod && sDst == DIB_Status_AppMod &&
1481 same_format(physDevSrc, physDevDst))
1482 {
1483 if (client_side_dib_copy( physDevSrc, src->visrect.left, src->visrect.top,
1484 physDevDst, dst->visrect.left, dst->visrect.top, width, height ))
1485 goto done;
1486 }
1487
1488 X11DRV_CoerceDIBSection( physDevDst, DIB_Status_GdiMod );
1489
1490 opcode = BITBLT_Opcodes[(rop >> 16) & 0xff];
1491
1492 /* a few optimizations for single-op ROPs */
1493 if (!fStretch && !opcode[1] && OP_SRCDST(opcode[0]) == OP_ARGS(SRC,DST))
1494 {
1495 if (same_format(physDevSrc, physDevDst))
1496 {
1497 wine_tsx11_lock();
1498 XSetFunction( gdi_display, physDevDst->gc, OP_ROP(*opcode) );
1499 wine_tsx11_unlock();
1500
1501 if (physDevSrc != physDevDst)
1502 {
1503 if (sSrc == DIB_Status_AppMod)
1504 {
1505 X11DRV_DIB_CopyDIBSection( physDevSrc, physDevDst, src->visrect.left, src->visrect.top,
1506 dst->visrect.left, dst->visrect.top, width, height );
1507 goto done;
1508 }
1509 X11DRV_CoerceDIBSection( physDevSrc, DIB_Status_GdiMod );
1510 }
1511 wine_tsx11_lock();
1512 XCopyArea( gdi_display, physDevSrc->drawable,
1513 physDevDst->drawable, physDevDst->gc,
1514 physDevSrc->dc_rect.left + src->visrect.left,
1515 physDevSrc->dc_rect.top + src->visrect.top,
1516 width, height,
1517 physDevDst->dc_rect.left + dst->visrect.left,
1518 physDevDst->dc_rect.top + dst->visrect.top );
1519 physDevDst->exposures++;
1520 wine_tsx11_unlock();
1521 goto done;
1522 }
1523 if (physDevSrc->depth == 1)
1524 {
1525 int fg, bg;
1526
1527 X11DRV_CoerceDIBSection( physDevSrc, DIB_Status_GdiMod );
1528 get_colors(physDevDst, physDevSrc, &fg, &bg);
1529 wine_tsx11_lock();
1530 XSetBackground( gdi_display, physDevDst->gc, fg );
1531 XSetForeground( gdi_display, physDevDst->gc, bg );
1532 XSetFunction( gdi_display, physDevDst->gc, OP_ROP(*opcode) );
1533 XCopyPlane( gdi_display, physDevSrc->drawable,
1534 physDevDst->drawable, physDevDst->gc,
1535 physDevSrc->dc_rect.left + src->visrect.left,
1536 physDevSrc->dc_rect.top + src->visrect.top,
1537 width, height,
1538 physDevDst->dc_rect.left + dst->visrect.left,
1539 physDevDst->dc_rect.top + dst->visrect.top, 1 );
1540 physDevDst->exposures++;
1541 wine_tsx11_unlock();
1542 goto done;
1543 }
1544 }
1545
1546 wine_tsx11_lock();
1547 tmpGC = XCreateGC( gdi_display, physDevDst->drawable, 0, NULL );
1548 XSetSubwindowMode( gdi_display, tmpGC, IncludeInferiors );
1549 XSetGraphicsExposures( gdi_display, tmpGC, False );
1550 src_pixmap = XCreatePixmap( gdi_display, root_window, width, height, physDevDst->depth );
1551 wine_tsx11_unlock();
1552
1553 if (physDevDst != physDevSrc) X11DRV_CoerceDIBSection( physDevSrc, DIB_Status_GdiMod );
1554
1555 if(!X11DRV_XRender_GetSrcAreaStretch( physDevSrc, physDevDst, src_pixmap, tmpGC, src, dst ))
1556 {
1557 if (fStretch)
1558 BITBLT_GetSrcAreaStretch( physDevSrc, physDevDst, src_pixmap, tmpGC, src, dst );
1559 else
1560 BITBLT_GetSrcArea( physDevSrc, physDevDst, src_pixmap, tmpGC, &src->visrect );
1561 }
1562
1563 execute_rop( physDevDst, src_pixmap, tmpGC, &dst->visrect, rop );
1564
1565 wine_tsx11_lock();
1566 XFreePixmap( gdi_display, src_pixmap );
1567 XFreeGC( gdi_display, tmpGC );
1568 wine_tsx11_unlock();
1569
1570 done:
1571 if (physDevDst != physDevSrc) X11DRV_UnlockDIBSection( physDevSrc, FALSE );
1572 X11DRV_UnlockDIBSection( physDevDst, TRUE );
1573 return TRUE;
1574 }
1575
1576
1577 /***********************************************************************
1578 * X11DRV_AlphaBlend
1579 */
1580 BOOL X11DRV_AlphaBlend( PHYSDEV dst_dev, struct bitblt_coords *dst,
1581 PHYSDEV src_dev, struct bitblt_coords *src, BLENDFUNCTION blendfn )
1582 {
1583 X11DRV_PDEVICE *physDevDst = get_x11drv_dev( dst_dev );
1584 X11DRV_PDEVICE *physDevSrc = get_x11drv_dev( src_dev ); /* FIXME: check that it's really an x11 dev */
1585
1586 if (src->x < 0 || src->y < 0 || src->width < 0 || src->height < 0 ||
1587 src->width > physDevSrc->drawable_rect.right - physDevSrc->drawable_rect.left - src->x ||
1588 src->height > physDevSrc->drawable_rect.bottom - physDevSrc->drawable_rect.top - src->y)
1589 {
1590 WARN( "Invalid src coords: (%d,%d), size %dx%d\n", src->x, src->y, src->width, src->height );
1591 SetLastError( ERROR_INVALID_PARAMETER );
1592 return FALSE;
1593 }
1594
1595 return XRender_AlphaBlend( physDevDst, dst, physDevSrc, src, blendfn );
1596 }
1597
1598
1599 static void free_heap_bits( struct gdi_image_bits *bits )
1600 {
1601 HeapFree( GetProcessHeap(), 0, bits->ptr );
1602 }
1603
1604 static void free_ximage_bits( struct gdi_image_bits *bits )
1605 {
1606 wine_tsx11_lock();
1607 XFree( bits->ptr );
1608 wine_tsx11_unlock();
1609 }
1610
1611 /* store the palette or color mask data in the bitmap info structure */
1612 static void set_color_info( PHYSDEV dev, const ColorShifts *color_shifts, BITMAPINFO *info )
1613 {
1614 DWORD *colors = (DWORD *)((char *)info + info->bmiHeader.biSize);
1615
1616 info->bmiHeader.biCompression = BI_RGB;
1617 info->bmiHeader.biClrUsed = 0;
1618
1619 switch (info->bmiHeader.biBitCount)
1620 {
1621 case 4:
1622 case 8:
1623 {
1624 RGBQUAD *rgb = (RGBQUAD *)colors;
1625 PALETTEENTRY palette[256];
1626 UINT i, count;
1627
1628 info->bmiHeader.biClrUsed = 1 << info->bmiHeader.biBitCount;
1629 count = X11DRV_GetSystemPaletteEntries( dev, 0, info->bmiHeader.biClrUsed, palette );
1630 for (i = 0; i < count; i++)
1631 {
1632 rgb[i].rgbRed = palette[i].peRed;
1633 rgb[i].rgbGreen = palette[i].peGreen;
1634 rgb[i].rgbBlue = palette[i].peBlue;
1635 rgb[i].rgbReserved = 0;
1636 }
1637 memset( &rgb[count], 0, (info->bmiHeader.biClrUsed - count) * sizeof(*rgb) );
1638 break;
1639 }
1640 case 16:
1641 colors[0] = color_shifts->logicalRed.max << color_shifts->logicalRed.shift;
1642 colors[1] = color_shifts->logicalGreen.max << color_shifts->logicalGreen.shift;
1643 colors[2] = color_shifts->logicalBlue.max << color_shifts->logicalBlue.shift;
1644 if (colors[0] != 0x7c00 || colors[1] != 0x03e0 || colors[2] != 0x001f)
1645 info->bmiHeader.biCompression = BI_BITFIELDS;
1646 break;
1647 case 32:
1648 colors[0] = color_shifts->logicalRed.max << color_shifts->logicalRed.shift;
1649 colors[1] = color_shifts->logicalGreen.max << color_shifts->logicalGreen.shift;
1650 colors[2] = color_shifts->logicalBlue.max << color_shifts->logicalBlue.shift;
1651 if (colors[0] != 0xff0000 || colors[1] != 0x00ff00 || colors[2] != 0x0000ff)
1652 info->bmiHeader.biCompression = BI_BITFIELDS;
1653 break;
1654 }
1655 }
1656
1657 /* check if the specified color info is suitable for PutImage */
1658 static BOOL matching_color_info( PHYSDEV dev, const ColorShifts *color_shifts, const BITMAPINFO *info )
1659 {
1660 DWORD *colors = (DWORD *)((char *)info + info->bmiHeader.biSize);
1661
1662 switch (info->bmiHeader.biBitCount)
1663 {
1664 case 1:
1665 if (info->bmiHeader.biCompression != BI_RGB) return FALSE;
1666 return !info->bmiHeader.biClrUsed; /* color map not allowed */
1667 case 4:
1668 case 8:
1669 {
1670 RGBQUAD *rgb = (RGBQUAD *)colors;
1671 PALETTEENTRY palette[256];
1672 UINT i, count;
1673
1674 if (info->bmiHeader.biCompression != BI_RGB) return FALSE;
1675 count = X11DRV_GetSystemPaletteEntries( dev, 0, 1 << info->bmiHeader.biBitCount, palette );
1676 if (count != info->bmiHeader.biClrUsed) return FALSE;
1677 for (i = 0; i < count; i++)
1678 {
1679 if (rgb[i].rgbRed != palette[i].peRed ||
1680 rgb[i].rgbGreen != palette[i].peGreen ||
1681 rgb[i].rgbBlue != palette[i].peBlue) return FALSE;
1682 }
1683 return TRUE;
1684 }
1685 case 16:
1686 if (info->bmiHeader.biCompression == BI_BITFIELDS)
1687 return (color_shifts->logicalRed.max << color_shifts->logicalRed.shift == colors[0] &&
1688 color_shifts->logicalGreen.max << color_shifts->logicalGreen.shift == colors[1] &&
1689 color_shifts->logicalBlue.max << color_shifts->logicalBlue.shift == colors[2]);
1690 if (info->bmiHeader.biCompression == BI_RGB)
1691 return (color_shifts->logicalRed.max << color_shifts->logicalRed.shift == 0x7c00 &&
1692 color_shifts->logicalGreen.max << color_shifts->logicalGreen.shift == 0x03e0 &&
1693 color_shifts->logicalBlue.max << color_shifts->logicalBlue.shift == 0x001f);
1694 break;
1695 case 32:
1696 if (info->bmiHeader.biCompression == BI_BITFIELDS)
1697 return (color_shifts->logicalRed.max << color_shifts->logicalRed.shift == colors[0] &&
1698 color_shifts->logicalGreen.max << color_shifts->logicalGreen.shift == colors[1] &&
1699 color_shifts->logicalBlue.max << color_shifts->logicalBlue.shift == colors[2]);
1700 /* fall through */
1701 case 24:
1702 if (info->bmiHeader.biCompression == BI_RGB)
1703 return (color_shifts->logicalRed.max << color_shifts->logicalRed.shift == 0xff0000 &&
1704 color_shifts->logicalGreen.max << color_shifts->logicalGreen.shift == 0x00ff00 &&
1705 color_shifts->logicalBlue.max << color_shifts->logicalBlue.shift == 0x0000ff);
1706 break;
1707 }
1708 return FALSE;
1709 }
1710
1711 /* copy the image bits, fixing up alignment and byte swapping as necessary */
1712 static DWORD copy_image_bits( BITMAPINFO *info, const ColorShifts *color_shifts, XImage *image,
1713 const struct gdi_image_bits *src_bits, struct gdi_image_bits *dst_bits,
1714 struct bitblt_coords *coords, const int *mapping, unsigned int zeropad_mask )
1715 {
1716 #ifdef WORDS_BIGENDIAN
1717 static const int client_byte_order = MSBFirst;
1718 #else
1719 static const int client_byte_order = LSBFirst;
1720 #endif
1721 BOOL need_byteswap;
1722 int x, y, height = coords->visrect.bottom - coords->visrect.top;
1723 int width_bytes = image->bytes_per_line;
1724 int padding_pos;
1725 unsigned char *src, *dst;
1726
1727 switch (info->bmiHeader.biBitCount)
1728 {
1729 case 1:
1730 need_byteswap = (image->bitmap_bit_order != MSBFirst);
1731 break;
1732 case 4:
1733 need_byteswap = (image->byte_order != MSBFirst);
1734 break;
1735 case 16:
1736 case 32:
1737 need_byteswap = (image->byte_order != client_byte_order);
1738 break;
1739 case 24:
1740 need_byteswap = ((image->byte_order == LSBFirst && color_shifts->logicalBlue.shift == 16) ||
1741 (image->byte_order == MSBFirst && color_shifts->logicalBlue.shift == 0));
1742 break;
1743 default:
1744 need_byteswap = FALSE;
1745 break;
1746 }
1747
1748 src = src_bits->ptr;
1749 if (info->bmiHeader.biHeight > 0)
1750 src += (info->bmiHeader.biHeight - coords->visrect.bottom) * width_bytes;
1751 else
1752 src += coords->visrect.top * width_bytes;
1753
1754 if ((need_byteswap && !src_bits->is_copy) || /* need to swap bytes */
1755 (zeropad_mask != ~0u && !src_bits->is_copy) || /* need to clear padding bytes */
1756 (mapping && !src_bits->is_copy) || /* need to remap pixels */
1757 (width_bytes & 3) || /* need to fixup line alignment */
1758 (info->bmiHeader.biHeight > 0)) /* need to flip vertically */
1759 {
1760 width_bytes = (width_bytes + 3) & ~3;
1761 info->bmiHeader.biSizeImage = height * width_bytes;
1762 if (!(dst_bits->ptr = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage )))
1763 return ERROR_OUTOFMEMORY;
1764 dst_bits->is_copy = TRUE;
1765 dst_bits->free = free_heap_bits;
1766 }
1767 else
1768 {
1769 /* swap bits in place */
1770 dst_bits->ptr = src;
1771 dst_bits->is_copy = src_bits->is_copy;
1772 dst_bits->free = NULL;
1773 if (!need_byteswap && zeropad_mask == ~0u && !mapping) return ERROR_SUCCESS; /* nothing to do */
1774 }
1775
1776 dst = dst_bits->ptr;
1777 padding_pos = width_bytes/sizeof(unsigned int) - 1;
1778
1779 if (info->bmiHeader.biHeight > 0)
1780 {
1781 dst += (height - 1) * width_bytes;
1782 width_bytes = -width_bytes;
1783 }
1784
1785 if (need_byteswap || mapping)
1786 {
1787 switch (info->bmiHeader.biBitCount)
1788 {
1789 case 1:
1790 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1791 {
1792 for (x = 0; x < image->bytes_per_line; x++)
1793 dst[x] = bit_swap[src[x]];
1794 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1795 }
1796 break;
1797 case 4:
1798 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1799 {
1800 if (mapping)
1801 for (x = 0; x < image->bytes_per_line; x++)
1802 dst[x] = (mapping[src[x] & 0x0f] << 4) | mapping[src[x] >> 4];
1803 else
1804 for (x = 0; x < image->bytes_per_line; x++)
1805 dst[x] = (src[x] << 4) | (src[x] >> 4);
1806 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1807 }
1808 break;
1809 case 8:
1810 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1811 {
1812 for (x = 0; x < image->bytes_per_line; x++)
1813 dst[x] = mapping[src[x]];
1814 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1815 }
1816 break;
1817 case 16:
1818 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1819 {
1820 for (x = 0; x < info->bmiHeader.biWidth; x++)
1821 ((USHORT *)dst)[x] = RtlUshortByteSwap( ((const USHORT *)src)[x] );
1822 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1823 }
1824 break;
1825 case 24:
1826 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1827 {
1828 for (x = 0; x < info->bmiHeader.biWidth; x++)
1829 {
1830 unsigned char tmp = src[3 * x];
1831 dst[3 * x] = src[3 * x + 2];
1832 dst[3 * x + 1] = src[3 * x + 1];
1833 dst[3 * x + 2] = tmp;
1834 }
1835 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1836 }
1837 break;
1838 case 32:
1839 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1840 for (x = 0; x < info->bmiHeader.biWidth; x++)
1841 ((ULONG *)dst)[x] = RtlUlongByteSwap( ((const ULONG *)src)[x] );
1842 break;
1843 }
1844 }
1845 else if (src != dst)
1846 {
1847 for (y = 0; y < height; y++, src += image->bytes_per_line, dst += width_bytes)
1848 {
1849 memcpy( dst, src, image->bytes_per_line );
1850 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1851 }
1852 }
1853 else /* only need to clear the padding */
1854 {
1855 for (y = 0; y < height; y++, dst += width_bytes)
1856 ((unsigned int *)dst)[padding_pos] &= zeropad_mask;
1857 }
1858 return ERROR_SUCCESS;
1859 }
1860
1861 /***********************************************************************
1862 * X11DRV_PutImage
1863 */
1864 DWORD X11DRV_PutImage( PHYSDEV dev, HBITMAP hbitmap, HRGN clip, BITMAPINFO *info,
1865 const struct gdi_image_bits *bits, struct bitblt_coords *src,
1866 struct bitblt_coords *dst, DWORD rop )
1867 {
1868 X11DRV_PDEVICE *physdev;
1869 X_PHYSBITMAP *bitmap;
1870 DWORD ret;
1871 XImage *image;
1872 int depth;
1873 struct gdi_image_bits dst_bits;
1874 const XPixmapFormatValues *format;
1875 const ColorShifts *color_shifts;
1876 const BYTE *opcode = BITBLT_Opcodes[(rop >> 16) & 0xff];
1877 const int *mapping = NULL;
1878
1879 if (hbitmap)
1880 {
1881 if (!(bitmap = X11DRV_get_phys_bitmap( hbitmap ))) return ERROR_INVALID_HANDLE;
1882 physdev = NULL;
1883 depth = bitmap->pixmap_depth;
1884 color_shifts = &bitmap->pixmap_color_shifts;
1885 }
1886 else
1887 {
1888 physdev = get_x11drv_dev( dev );
1889 bitmap = NULL;
1890 depth = physdev->depth;
1891 color_shifts = physdev->color_shifts;
1892 }
1893 format = pixmap_formats[depth];
1894
1895 if (info->bmiHeader.biPlanes != 1) goto update_format;
1896 if (info->bmiHeader.biBitCount != format->bits_per_pixel) goto update_format;
1897 /* FIXME: could try to handle 1-bpp using XCopyPlane */
1898 if (!matching_color_info( dev, color_shifts, info )) goto update_format;
1899 if (!bits) return ERROR_SUCCESS; /* just querying the format */
1900 if ((src->width != dst->width) || (src->height != dst->height)) return ERROR_TRANSFORM_NOT_SUPPORTED;
1901
1902 wine_tsx11_lock();
1903 image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0, NULL,
1904 info->bmiHeader.biWidth, src->visrect.bottom - src->visrect.top, 32, 0 );
1905 wine_tsx11_unlock();
1906 if (!image) return ERROR_OUTOFMEMORY;
1907
1908 if (image->bits_per_pixel == 4 || image->bits_per_pixel == 8)
1909 {
1910 if (bitmap || (!opcode[1] && OP_SRCDST(opcode[0]) == OP_ARGS(SRC,DST)))
1911 mapping = X11DRV_PALETTE_PaletteToXPixel;
1912 }
1913
1914 ret = copy_image_bits( info, color_shifts, image, bits, &dst_bits, src, mapping, ~0u );
1915
1916 if (!ret)
1917 {
1918 int width = dst->visrect.right - dst->visrect.left;
1919 int height = dst->visrect.bottom - dst->visrect.top;
1920
1921 image->data = dst_bits.ptr;
1922 /* hack: make sure the bits are readable if we are reading from a DIB section */
1923 /* to be removed once we get rid of DIB access protections */
1924 if (!dst_bits.is_copy) IsBadReadPtr( dst_bits.ptr, height * image->bytes_per_line );
1925
1926 if (bitmap)
1927 {
1928 RGNDATA *clip_data = NULL;
1929 GC gc;
1930
1931 if (clip) clip_data = X11DRV_GetRegionData( clip, 0 );
1932 X11DRV_DIB_Lock( bitmap, DIB_Status_GdiMod );
1933
1934 wine_tsx11_lock();
1935 gc = XCreateGC( gdi_display, bitmap->pixmap, 0, NULL );
1936 XSetGraphicsExposures( gdi_display, gc, False );
1937 if (clip_data) XSetClipRectangles( gdi_display, gc, 0, 0, (XRectangle *)clip_data->Buffer,
1938 clip_data->rdh.nCount, YXBanded );
1939 XPutImage( gdi_display, bitmap->pixmap, gc, image, src->visrect.left, 0,
1940 dst->visrect.left, dst->visrect.top, width, height );
1941 XFreeGC( gdi_display, gc );
1942 wine_tsx11_unlock();
1943
1944 X11DRV_DIB_Unlock( bitmap, TRUE );
1945 HeapFree( GetProcessHeap(), 0, clip_data );
1946 }
1947 else
1948 {
1949 HRGN saved_region = 0;
1950
1951 if (clip) saved_region = add_extra_clipping_region( physdev, clip );
1952 X11DRV_LockDIBSection( physdev, DIB_Status_GdiMod );
1953
1954 /* optimization for single-op ROPs */
1955 if (!opcode[1] && OP_SRCDST(opcode[0]) == OP_ARGS(SRC,DST))
1956 {
1957 wine_tsx11_lock();
1958 XSetFunction( gdi_display, physdev->gc, OP_ROP(*opcode) );
1959 XPutImage( gdi_display, physdev->drawable, physdev->gc, image, src->visrect.left, 0,
1960 physdev->dc_rect.left + dst->visrect.left,
1961 physdev->dc_rect.top + dst->visrect.top, width, height );
1962 wine_tsx11_unlock();
1963 }
1964 else
1965 {
1966 Pixmap src_pixmap;
1967 GC gc;
1968
1969 wine_tsx11_lock();
1970 gc = XCreateGC( gdi_display, physdev->drawable, 0, NULL );
1971 XSetSubwindowMode( gdi_display, gc, IncludeInferiors );
1972 XSetGraphicsExposures( gdi_display, gc, False );
1973 src_pixmap = XCreatePixmap( gdi_display, root_window, width, height, depth );
1974 XPutImage( gdi_display, src_pixmap, gc, image, src->visrect.left, 0, 0, 0, width, height );
1975 wine_tsx11_unlock();
1976
1977 execute_rop( physdev, src_pixmap, gc, &dst->visrect, rop );
1978
1979 wine_tsx11_lock();
1980 XFreePixmap( gdi_display, src_pixmap );
1981 XFreeGC( gdi_display, gc );
1982 wine_tsx11_unlock();
1983 }
1984
1985 X11DRV_UnlockDIBSection( physdev, !ret );
1986 if (saved_region) restore_clipping_region( physdev, saved_region );
1987 }
1988 image->data = NULL;
1989 }
1990
1991 wine_tsx11_lock();
1992 XDestroyImage( image );
1993 wine_tsx11_unlock();
1994 if (dst_bits.free) dst_bits.free( &dst_bits );
1995 return ret;
1996
1997 update_format:
1998 info->bmiHeader.biPlanes = 1;
1999 info->bmiHeader.biBitCount = format->bits_per_pixel;
2000 if (info->bmiHeader.biHeight > 0) info->bmiHeader.biHeight = -info->bmiHeader.biHeight;
2001 set_color_info( dev, color_shifts, info );
2002 return ERROR_BAD_FORMAT;
2003 }
2004
2005 /***********************************************************************
2006 * X11DRV_GetImage
2007 */
2008 DWORD X11DRV_GetImage( PHYSDEV dev, HBITMAP hbitmap, BITMAPINFO *info,
2009 struct gdi_image_bits *bits, struct bitblt_coords *src )
2010 {
2011 X11DRV_PDEVICE *physdev;
2012 X_PHYSBITMAP *bitmap;
2013 DWORD ret = ERROR_SUCCESS;
2014 XImage *image;
2015 UINT align, x, y, width, height;
2016 int depth;
2017 struct gdi_image_bits src_bits;
2018 const XPixmapFormatValues *format;
2019 const ColorShifts *color_shifts;
2020 const int *mapping = NULL;
2021
2022 if (hbitmap)
2023 {
2024 if (!(bitmap = X11DRV_get_phys_bitmap( hbitmap ))) return ERROR_INVALID_HANDLE;
2025 physdev = NULL;
2026 depth = bitmap->pixmap_depth;
2027 color_shifts = &bitmap->pixmap_color_shifts;
2028 }
2029 else
2030 {
2031 physdev = get_x11drv_dev( dev );
2032 bitmap = NULL;
2033 depth = physdev->depth;
2034 color_shifts = physdev->color_shifts;
2035 }
2036 format = pixmap_formats[depth];
2037
2038 /* align start and width to 32-bit boundary */
2039 switch (format->bits_per_pixel)
2040 {
2041 case 1: align = 32; break;
2042 case 4: align = 8; mapping = X11DRV_PALETTE_XPixelToPalette; break;
2043 case 8: align = 4; mapping = X11DRV_PALETTE_XPixelToPalette; break;
2044 case 16: align = 2; break;
2045 case 24: align = 4; break;
2046 case 32: align = 1; break;
2047 default:
2048 FIXME( "depth %u bpp %u not supported yet\n", depth, format->bits_per_pixel );
2049 return ERROR_BAD_FORMAT;
2050 }
2051
2052 info->bmiHeader.biSize = sizeof(info->bmiHeader);
2053 info->bmiHeader.biPlanes = 1;
2054 info->bmiHeader.biBitCount = format->bits_per_pixel;
2055 info->bmiHeader.biXPelsPerMeter = 0;
2056 info->bmiHeader.biYPelsPerMeter = 0;
2057 info->bmiHeader.biClrImportant = 0;
2058 set_color_info( dev, color_shifts, info );
2059
2060 if (!bits) return ERROR_SUCCESS; /* just querying the color information */
2061
2062 x = src->visrect.left & ~(align - 1);
2063 y = src->visrect.top;
2064 width = src->visrect.right - x;
2065 height = src->visrect.bottom - src->visrect.top;
2066 if (format->scanline_pad != 32) width = (width + (align - 1)) & ~(align - 1);
2067 /* make the source rectangle relative to the returned bits */
2068 src->x -= x;
2069 src->y -= y;
2070 OffsetRect( &src->visrect, -x, -y );
2071
2072 if (bitmap)
2073 {
2074 BITMAP bm;
2075 GetObjectW( hbitmap, sizeof(bm), &bm );
2076 width = min( width, bm.bmWidth - x );
2077 height = min( height, bm.bmHeight - y );
2078 X11DRV_DIB_Lock( bitmap, DIB_Status_GdiMod );
2079 wine_tsx11_lock();
2080 image = XGetImage( gdi_display, bitmap->pixmap, x, y, width, height, AllPlanes, ZPixmap );
2081 wine_tsx11_unlock();
2082 X11DRV_DIB_Unlock( bitmap, TRUE );
2083 }
2084 else if (GetObjectType( dev->hdc ) == OBJ_MEMDC)
2085 {
2086 X11DRV_LockDIBSection( physdev, DIB_Status_GdiMod );
2087 width = min( width, physdev->dc_rect.right - physdev->dc_rect.left - x );
2088 height = min( height, physdev->dc_rect.bottom - physdev->dc_rect.top - y );
2089 wine_tsx11_lock();
2090 image = XGetImage( gdi_display, physdev->drawable,
2091 physdev->dc_rect.left + x, physdev->dc_rect.top + y,
2092 width, height, AllPlanes, ZPixmap );
2093 wine_tsx11_unlock();
2094 X11DRV_UnlockDIBSection( physdev, FALSE );
2095 }
2096 else
2097 {
2098 Pixmap pixmap;
2099
2100 wine_tsx11_lock();
2101 /* use a temporary pixmap to avoid BadMatch errors */
2102 pixmap = XCreatePixmap( gdi_display, root_window, width, height, depth );
2103 XCopyArea( gdi_display, physdev->drawable, pixmap, get_bitmap_gc(depth),
2104 physdev->dc_rect.left + x, physdev->dc_rect.top + y, width, height, 0, 0 );
2105 image = XGetImage( gdi_display, pixmap, 0, 0, width, height, AllPlanes, ZPixmap );
2106 XFreePixmap( gdi_display, pixmap );
2107 wine_tsx11_unlock();
2108 }
2109 if (!image) return ERROR_OUTOFMEMORY;
2110
2111 info->bmiHeader.biWidth = width;
2112 info->bmiHeader.biHeight = -height;
2113 info->bmiHeader.biSizeImage = height * image->bytes_per_line;
2114
2115 src_bits.ptr = image->data;
2116 src_bits.is_copy = TRUE;
2117 ret = copy_image_bits( info, color_shifts, image, &src_bits, bits, src, mapping,
2118 zeropad_masks[(width * image->bits_per_pixel) & 31] );
2119
2120 if (!ret && bits->ptr == image->data)
2121 {
2122 bits->free = free_ximage_bits;
2123 image->data = NULL;
2124 }
2125 wine_tsx11_lock();
2126 XDestroyImage( image );
2127 wine_tsx11_unlock();
2128 return ret;
2129 }
Windows API implementation