?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Use popup menu from shdoclc.dll.
[wine/multimedia.git] / dlls / winex11.drv / bitblt.c
blob73c62318f15c5dcaf92dd148feb2bc9f7e9271d5
1 /*
2 * GDI bit-blit operations
3 *
4 * Copyright 1993, 1994 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 "winreg.h"
33 #include "winuser.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,TMP,GXnand),
83 OP(TMP,DST,GXand), OP(SRC,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,TMP,GXnand),
91 OP(TMP,DST,GXand), OP(SRC,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,TMP,GXxor),
95 OP(TMP,DST,GXand), OP(SRC,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,TMP,GXand),
111 OP(TMP,DST,GXor), OP(SRC,DST,GXxor) }, /* 0x26 S^(D|(S&P)) */
112 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXequiv),
113 OP(TMP,DST,GXor), OP(SRC,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,TMP,GXand),
116 OP(TMP,DST,GXor), OP(SRC,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(SRC,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
448 #ifdef BITBLT_TEST /* Opcodes test */
449
450 static int do_bitop( int s, int d, int rop )
451 {
452 int res;
453 switch(rop)
454 {
455 case GXclear: res = 0; break;
456 case GXand: res = s & d; break;
457 case GXandReverse: res = s & ~d; break;
458 case GXcopy: res = s; break;
459 case GXandInverted: res = ~s & d; break;
460 case GXnoop: res = d; break;
461 case GXxor: res = s ^ d; break;
462 case GXor: res = s | d; break;
463 case GXnor: res = ~(s | d); break;
464 case GXequiv: res = ~s ^ d; break;
465 case GXinvert: res = ~d; break;
466 case GXorReverse: res = s | ~d; break;
467 case GXcopyInverted: res = ~s; break;
468 case GXorInverted: res = ~s | d; break;
469 case GXnand: res = ~(s & d); break;
470 case GXset: res = 1; break;
471 }
472 return res & 1;
473 }
474
475 int main()
476 {
477 int rop, i, res, src, dst, pat, tmp, dstUsed;
478 const BYTE *opcode;
479
480 for (rop = 0; rop < 256; rop++)
481 {
482 res = dstUsed = 0;
483 for (i = 0; i < 8; i++)
484 {
485 pat = (i >> 2) & 1;
486 src = (i >> 1) & 1;
487 dst = i & 1;
488 for (opcode = BITBLT_Opcodes[rop]; *opcode; opcode++)
489 {
490 switch(*opcode >> 4)
491 {
492 case OP_ARGS(DST,TMP):
493 tmp = do_bitop( dst, tmp, *opcode & 0xf );
494 break;
495 case OP_ARGS(DST,SRC):
496 src = do_bitop( dst, src, *opcode & 0xf );
497 break;
498 case OP_ARGS(SRC,TMP):
499 tmp = do_bitop( src, tmp, *opcode & 0xf );
500 break;
501 case OP_ARGS(SRC,DST):
502 dst = do_bitop( src, dst, *opcode & 0xf );
503 dstUsed = 1;
504 break;
505 case OP_ARGS(PAT,TMP):
506 tmp = do_bitop( pat, tmp, *opcode & 0xf );
507 break;
508 case OP_ARGS(PAT,DST):
509 dst = do_bitop( pat, dst, *opcode & 0xf );
510 dstUsed = 1;
511 break;
512 case OP_ARGS(PAT,SRC):
513 src = do_bitop( pat, src, *opcode & 0xf );
514 break;
515 case OP_ARGS(TMP,DST):
516 dst = do_bitop( tmp, dst, *opcode & 0xf );
517 dstUsed = 1;
518 break;
519 case OP_ARGS(TMP,SRC):
520 src = do_bitop( tmp, src, *opcode & 0xf );
521 break;
522 default:
523 printf( "Invalid opcode %x\n", *opcode );
524 }
525 }
526 if (!dstUsed) dst = src;
527 if (dst) res |= 1 << i;
528 }
529 if (res != rop) printf( "%02x: ERROR, res=%02x\n", rop, res );
530 }
531
532 return 0;
533 }
534
535 #endif /* BITBLT_TEST */
536
537
538 static void get_colors(X11DRV_PDEVICE *physDevDst, X11DRV_PDEVICE *physDevSrc,
539 int *fg, int *bg)
540 {
541 RGBQUAD rgb[2];
542
543 *fg = physDevDst->textPixel;
544 *bg = physDevDst->backgroundPixel;
545 if(physDevSrc->depth == 1) {
546 if(GetDIBColorTable(physDevSrc->hdc, 0, 2, rgb) == 2) {
547 DWORD logcolor;
548 logcolor = RGB(rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue);
549 *fg = X11DRV_PALETTE_ToPhysical( physDevDst, logcolor );
550 logcolor = RGB(rgb[1].rgbRed, rgb[1].rgbGreen,rgb[1].rgbBlue);
551 *bg = X11DRV_PALETTE_ToPhysical( physDevDst, logcolor );
552 }
553 }
554 }
555
556 /***********************************************************************
557 * BITBLT_StretchRow
558 *
559 * Stretch a row of pixels. Helper function for BITBLT_StretchImage.
560 */
561 static void BITBLT_StretchRow( int *rowSrc, int *rowDst,
562 INT startDst, INT widthDst,
563 INT xinc, INT xoff, WORD mode )
564 {
565 register INT xsrc = xinc * startDst + xoff;
566 rowDst += startDst;
567 switch(mode)
568 {
569 case STRETCH_ANDSCANS:
570 for(; widthDst > 0; widthDst--, xsrc += xinc)
571 *rowDst++ &= rowSrc[xsrc >> 16];
572 break;
573 case STRETCH_ORSCANS:
574 for(; widthDst > 0; widthDst--, xsrc += xinc)
575 *rowDst++ |= rowSrc[xsrc >> 16];
576 break;
577 case STRETCH_DELETESCANS:
578 for(; widthDst > 0; widthDst--, xsrc += xinc)
579 *rowDst++ = rowSrc[xsrc >> 16];
580 break;
581 }
582 }
583
584
585 /***********************************************************************
586 * BITBLT_ShrinkRow
587 *
588 * Shrink a row of pixels. Helper function for BITBLT_StretchImage.
589 */
590 static void BITBLT_ShrinkRow( int *rowSrc, int *rowDst,
591 INT startSrc, INT widthSrc,
592 INT xinc, INT xoff, WORD mode )
593 {
594 register INT xdst = xinc * startSrc + xoff;
595 rowSrc += startSrc;
596 switch(mode)
597 {
598 case STRETCH_ORSCANS:
599 for(; widthSrc > 0; widthSrc--, xdst += xinc)
600 rowDst[xdst >> 16] |= *rowSrc++;
601 break;
602 case STRETCH_ANDSCANS:
603 for(; widthSrc > 0; widthSrc--, xdst += xinc)
604 rowDst[xdst >> 16] &= *rowSrc++;
605 break;
606 case STRETCH_DELETESCANS:
607 for(; widthSrc > 0; widthSrc--, xdst += xinc)
608 rowDst[xdst >> 16] = *rowSrc++;
609 break;
610 }
611 }
612
613
614 /***********************************************************************
615 * BITBLT_GetRow
616 *
617 * Retrieve a row from an image. Helper function for BITBLT_StretchImage.
618 */
619 static void BITBLT_GetRow( XImage *image, int *pdata, INT row,
620 INT start, INT width, INT depthDst,
621 int fg, int bg, BOOL swap)
622 {
623 register INT i;
624
625 assert( (row >= 0) && (row < image->height) );
626 assert( (start >= 0) && (width <= image->width) );
627
628 pdata += swap ? start+width-1 : start;
629 if (image->depth == depthDst) /* color -> color */
630 {
631 if (X11DRV_PALETTE_XPixelToPalette && (depthDst != 1))
632 if (swap) for (i = 0; i < width; i++)
633 *pdata-- = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )];
634 else for (i = 0; i < width; i++)
635 *pdata++ = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )];
636 else
637 if (swap) for (i = 0; i < width; i++)
638 *pdata-- = XGetPixel( image, i, row );
639 else for (i = 0; i < width; i++)
640 *pdata++ = XGetPixel( image, i, row );
641 }
642 else
643 {
644 if (image->depth == 1) /* monochrome -> color */
645 {
646 if (X11DRV_PALETTE_XPixelToPalette)
647 {
648 fg = X11DRV_PALETTE_XPixelToPalette[fg];
649 bg = X11DRV_PALETTE_XPixelToPalette[bg];
650 }
651 if (swap) for (i = 0; i < width; i++)
652 *pdata-- = XGetPixel( image, i, row ) ? bg : fg;
653 else for (i = 0; i < width; i++)
654 *pdata++ = XGetPixel( image, i, row ) ? bg : fg;
655 }
656 else /* color -> monochrome */
657 {
658 if (swap) for (i = 0; i < width; i++)
659 *pdata-- = (XGetPixel( image, i, row ) == bg) ? 1 : 0;
660 else for (i = 0; i < width; i++)
661 *pdata++ = (XGetPixel( image, i, row ) == bg) ? 1 : 0;
662 }
663 }
664 }
665
666
667 /***********************************************************************
668 * BITBLT_StretchImage
669 *
670 * Stretch an X image.
671 * FIXME: does not work for full 32-bit coordinates.
672 */
673 static void BITBLT_StretchImage( XImage *srcImage, XImage *dstImage,
674 INT widthSrc, INT heightSrc,
675 INT widthDst, INT heightDst,
676 RECT *visRectSrc, RECT *visRectDst,
677 int foreground, int background, WORD mode )
678 {
679 int *rowSrc, *rowDst, *pixel;
680 char *pdata;
681 INT xinc, xoff, yinc, ysrc, ydst;
682 register INT x, y;
683 BOOL hstretch, vstretch, hswap, vswap;
684
685 hswap = ((int)widthSrc * widthDst) < 0;
686 vswap = ((int)heightSrc * heightDst) < 0;
687 widthSrc = abs(widthSrc);
688 heightSrc = abs(heightSrc);
689 widthDst = abs(widthDst);
690 heightDst = abs(heightDst);
691
692 if (!(rowSrc = HeapAlloc( GetProcessHeap(), 0,
693 (widthSrc+widthDst)*sizeof(int) ))) return;
694 rowDst = rowSrc + widthSrc;
695
696 /* When stretching, all modes are the same, and DELETESCANS is faster */
697 if ((widthSrc < widthDst) && (heightSrc < heightDst))
698 mode = STRETCH_DELETESCANS;
699
700 if (mode == STRETCH_HALFTONE) /* FIXME */
701 mode = STRETCH_DELETESCANS;
702
703 if (mode != STRETCH_DELETESCANS)
704 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
705 widthDst*sizeof(int) );
706
707 hstretch = (widthSrc < widthDst);
708 vstretch = (heightSrc < heightDst);
709
710 if (hstretch)
711 {
712 xinc = ((int)widthSrc << 16) / widthDst;
713 xoff = ((widthSrc << 16) - (xinc * widthDst)) / 2;
714 }
715 else
716 {
717 xinc = ((int)widthDst << 16) / widthSrc;
718 xoff = ((widthDst << 16) - (xinc * widthSrc)) / 2;
719 }
720
721 if (vstretch)
722 {
723 yinc = ((int)heightSrc << 16) / heightDst;
724 ydst = visRectDst->top;
725 if (vswap)
726 {
727 ysrc = yinc * (heightDst - ydst - 1);
728 yinc = -yinc;
729 }
730 else
731 ysrc = yinc * ydst;
732
733 for ( ; (ydst < visRectDst->bottom); ysrc += yinc, ydst++)
734 {
735 if (((ysrc >> 16) < visRectSrc->top) ||
736 ((ysrc >> 16) >= visRectSrc->bottom)) continue;
737
738 /* Retrieve a source row */
739 BITBLT_GetRow( srcImage, rowSrc, (ysrc >> 16) - visRectSrc->top,
740 hswap ? widthSrc - visRectSrc->right
741 : visRectSrc->left,
742 visRectSrc->right - visRectSrc->left,
743 dstImage->depth, foreground, background, hswap );
744
745 /* Stretch or shrink it */
746 if (hstretch)
747 BITBLT_StretchRow( rowSrc, rowDst, visRectDst->left,
748 visRectDst->right - visRectDst->left,
749 xinc, xoff, mode );
750 else BITBLT_ShrinkRow( rowSrc, rowDst,
751 hswap ? widthSrc - visRectSrc->right
752 : visRectSrc->left,
753 visRectSrc->right - visRectSrc->left,
754 xinc, xoff, mode );
755
756 /* Store the destination row */
757 pixel = rowDst + visRectDst->right - 1;
758 y = ydst - visRectDst->top;
759 for (x = visRectDst->right-visRectDst->left-1; x >= 0; x--)
760 XPutPixel( dstImage, x, y, *pixel-- );
761 if (mode != STRETCH_DELETESCANS)
762 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
763 widthDst*sizeof(int) );
764
765 /* Make copies of the destination row */
766
767 pdata = dstImage->data + dstImage->bytes_per_line * y;
768 while (((ysrc + yinc) >> 16 == ysrc >> 16) &&
769 (ydst < visRectDst->bottom-1))
770 {
771 memcpy( pdata + dstImage->bytes_per_line, pdata,
772 dstImage->bytes_per_line );
773 pdata += dstImage->bytes_per_line;
774 ysrc += yinc;
775 ydst++;
776 }
777 }
778 }
779 else /* Shrinking */
780 {
781 yinc = ((int)heightDst << 16) / heightSrc;
782 ysrc = visRectSrc->top;
783 ydst = ((heightDst << 16) - (yinc * heightSrc)) / 2;
784 if (vswap)
785 {
786 ydst += yinc * (heightSrc - ysrc - 1);
787 yinc = -yinc;
788 }
789 else
790 ydst += yinc * ysrc;
791
792 for( ; (ysrc < visRectSrc->bottom); ydst += yinc, ysrc++)
793 {
794 if (((ydst >> 16) < visRectDst->top) ||
795 ((ydst >> 16) >= visRectDst->bottom)) continue;
796
797 /* Retrieve a source row */
798 BITBLT_GetRow( srcImage, rowSrc, ysrc - visRectSrc->top,
799 hswap ? widthSrc - visRectSrc->right
800 : visRectSrc->left,
801 visRectSrc->right - visRectSrc->left,
802 dstImage->depth, foreground, background, hswap );
803
804 /* Stretch or shrink it */
805 if (hstretch)
806 BITBLT_StretchRow( rowSrc, rowDst, visRectDst->left,
807 visRectDst->right - visRectDst->left,
808 xinc, xoff, mode );
809 else BITBLT_ShrinkRow( rowSrc, rowDst,
810 hswap ? widthSrc - visRectSrc->right
811 : visRectSrc->left,
812 visRectSrc->right - visRectSrc->left,
813 xinc, xoff, mode );
814
815 /* Merge several source rows into the destination */
816 if (mode == STRETCH_DELETESCANS)
817 {
818 /* Simply skip the overlapping rows */
819 while (((ydst + yinc) >> 16 == ydst >> 16) &&
820 (ysrc < visRectSrc->bottom-1))
821 {
822 ydst += yinc;
823 ysrc++;
824 }
825 }
826 else if (((ydst + yinc) >> 16 == ydst >> 16) &&
827 (ysrc < visRectSrc->bottom-1))
828 continue; /* Restart loop for next overlapping row */
829
830 /* Store the destination row */
831 pixel = rowDst + visRectDst->right - 1;
832 y = (ydst >> 16) - visRectDst->top;
833 for (x = visRectDst->right-visRectDst->left-1; x >= 0; x--)
834 XPutPixel( dstImage, x, y, *pixel-- );
835 if (mode != STRETCH_DELETESCANS)
836 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
837 widthDst*sizeof(int) );
838 }
839 }
840 HeapFree( GetProcessHeap(), 0, rowSrc );
841 }
842
843
844 /***********************************************************************
845 * BITBLT_GetSrcAreaStretch
846 *
847 * Retrieve an area from the source DC, stretching and mapping all the
848 * pixels to Windows colors.
849 */
850 static int BITBLT_GetSrcAreaStretch( X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
851 Pixmap pixmap, GC gc,
852 INT xSrc, INT ySrc,
853 INT widthSrc, INT heightSrc,
854 INT xDst, INT yDst,
855 INT widthDst, INT heightDst,
856 RECT *visRectSrc, RECT *visRectDst )
857 {
858 XImage *imageSrc, *imageDst;
859 RECT rectSrc = *visRectSrc;
860 RECT rectDst = *visRectDst;
861 int fg, bg;
862
863 if (widthSrc < 0) xSrc += widthSrc;
864 if (widthDst < 0) xDst += widthDst;
865 if (heightSrc < 0) ySrc += heightSrc;
866 if (heightDst < 0) yDst += heightDst;
867 rectSrc.left -= xSrc;
868 rectSrc.right -= xSrc;
869 rectSrc.top -= ySrc;
870 rectSrc.bottom -= ySrc;
871 rectDst.left -= xDst;
872 rectDst.right -= xDst;
873 rectDst.top -= yDst;
874 rectDst.bottom -= yDst;
875
876 get_colors(physDevDst, physDevSrc, &fg, &bg);
877 /* FIXME: avoid BadMatch errors */
878 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
879 physDevSrc->org.x + visRectSrc->left,
880 physDevSrc->org.y + visRectSrc->top,
881 visRectSrc->right - visRectSrc->left,
882 visRectSrc->bottom - visRectSrc->top,
883 AllPlanes, ZPixmap );
884 imageDst = X11DRV_DIB_CreateXImage( rectDst.right - rectDst.left,
885 rectDst.bottom - rectDst.top, physDevDst->depth );
886 BITBLT_StretchImage( imageSrc, imageDst, widthSrc, heightSrc,
887 widthDst, heightDst, &rectSrc, &rectDst,
888 fg, physDevDst->depth != 1 ?
889 bg : physDevSrc->backgroundPixel,
890 GetStretchBltMode(physDevDst->hdc) );
891 XPutImage( gdi_display, pixmap, gc, imageDst, 0, 0, 0, 0,
892 rectDst.right - rectDst.left, rectDst.bottom - rectDst.top );
893 XDestroyImage( imageSrc );
894 XDestroyImage( imageDst );
895 return 0; /* no exposure events generated */
896 }
897
898
899 /***********************************************************************
900 * BITBLT_GetSrcArea
901 *
902 * Retrieve an area from the source DC, mapping all the
903 * pixels to Windows colors.
904 */
905 static int BITBLT_GetSrcArea( X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
906 Pixmap pixmap, GC gc, INT xSrc, INT ySrc, RECT *visRectSrc )
907 {
908 XImage *imageSrc, *imageDst;
909 register INT x, y;
910 int exposures = 0;
911 INT width = visRectSrc->right - visRectSrc->left;
912 INT height = visRectSrc->bottom - visRectSrc->top;
913 int fg, bg;
914
915 if (physDevSrc->depth == physDevDst->depth)
916 {
917 if (!X11DRV_PALETTE_XPixelToPalette ||
918 (physDevDst->depth == 1)) /* monochrome -> monochrome */
919 {
920 if (physDevDst->depth == 1)
921 {
922 /* MSDN says if StretchBlt must convert a bitmap from monochrome
923 to color or vice versa, the forground and background color of
924 the device context are used. In fact, it also applies to the
925 case when it is converted from mono to mono. */
926 XSetBackground( gdi_display, gc, physDevDst->textPixel );
927 XSetForeground( gdi_display, gc, physDevDst->backgroundPixel );
928 XCopyPlane( gdi_display, physDevSrc->drawable, pixmap, gc,
929 physDevSrc->org.x + visRectSrc->left,
930 physDevSrc->org.y + visRectSrc->top,
931 width, height, 0, 0, 1);
932 }
933 else
934 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc,
935 physDevSrc->org.x + visRectSrc->left,
936 physDevSrc->org.y + visRectSrc->top,
937 width, height, 0, 0);
938 exposures++;
939 }
940 else /* color -> color */
941 {
942 if (GetObjectType(physDevSrc->hdc) == OBJ_MEMDC)
943 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
944 physDevSrc->org.x + visRectSrc->left,
945 physDevSrc->org.y + visRectSrc->top,
946 width, height, AllPlanes, ZPixmap );
947 else
948 {
949 /* Make sure we don't get a BadMatch error */
950 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc,
951 physDevSrc->org.x + visRectSrc->left,
952 physDevSrc->org.y + visRectSrc->top,
953 width, height, 0, 0);
954 exposures++;
955 imageSrc = XGetImage( gdi_display, pixmap, 0, 0, width, height,
956 AllPlanes, ZPixmap );
957 }
958 for (y = 0; y < height; y++)
959 for (x = 0; x < width; x++)
960 XPutPixel(imageSrc, x, y,
961 X11DRV_PALETTE_XPixelToPalette[XGetPixel(imageSrc, x, y)]);
962 XPutImage( gdi_display, pixmap, gc, imageSrc,
963 0, 0, 0, 0, width, height );
964 XDestroyImage( imageSrc );
965 }
966 }
967 else
968 {
969 if (physDevSrc->depth == 1) /* monochrome -> color */
970 {
971 get_colors(physDevDst, physDevSrc, &fg, &bg);
972
973 if (X11DRV_PALETTE_XPixelToPalette)
974 {
975 XSetBackground( gdi_display, gc,
976 X11DRV_PALETTE_XPixelToPalette[fg] );
977 XSetForeground( gdi_display, gc,
978 X11DRV_PALETTE_XPixelToPalette[bg]);
979 }
980 else
981 {
982 XSetBackground( gdi_display, gc, fg );
983 XSetForeground( gdi_display, gc, bg );
984 }
985 XCopyPlane( gdi_display, physDevSrc->drawable, pixmap, gc,
986 physDevSrc->org.x + visRectSrc->left,
987 physDevSrc->org.y + visRectSrc->top,
988 width, height, 0, 0, 1 );
989 exposures++;
990 }
991 else /* color -> monochrome */
992 {
993 /* FIXME: avoid BadMatch error */
994 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
995 physDevSrc->org.x + visRectSrc->left,
996 physDevSrc->org.y + visRectSrc->top,
997 width, height, AllPlanes, ZPixmap );
998 if (!imageSrc)
999 {
1000 return exposures;
1001 }
1002 imageDst = X11DRV_DIB_CreateXImage( width, height, physDevDst->depth );
1003 if (!imageDst)
1004 {
1005 XDestroyImage(imageSrc);
1006 return exposures;
1007 }
1008 for (y = 0; y < height; y++)
1009 for (x = 0; x < width; x++)
1010 XPutPixel(imageDst, x, y, (XGetPixel(imageSrc,x,y) ==
1011 physDevSrc->backgroundPixel) );
1012 XPutImage( gdi_display, pixmap, gc, imageDst,
1013 0, 0, 0, 0, width, height );
1014 XDestroyImage( imageSrc );
1015 XDestroyImage( imageDst );
1016 }
1017 }
1018 return exposures;
1019 }
1020
1021
1022 /***********************************************************************
1023 * BITBLT_GetDstArea
1024 *
1025 * Retrieve an area from the destination DC, mapping all the
1026 * pixels to Windows colors.
1027 */
1028 static int BITBLT_GetDstArea(X11DRV_PDEVICE *physDev, Pixmap pixmap, GC gc, RECT *visRectDst)
1029 {
1030 int exposures = 0;
1031 INT width = visRectDst->right - visRectDst->left;
1032 INT height = visRectDst->bottom - visRectDst->top;
1033
1034 if (!X11DRV_PALETTE_XPixelToPalette || (physDev->depth == 1) ||
1035 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) )
1036 {
1037 XCopyArea( gdi_display, physDev->drawable, pixmap, gc,
1038 physDev->org.x + visRectDst->left, physDev->org.y + visRectDst->top,
1039 width, height, 0, 0 );
1040 exposures++;
1041 }
1042 else
1043 {
1044 register INT x, y;
1045 XImage *image;
1046
1047 if (GetObjectType( physDev->hdc ) == OBJ_MEMDC)
1048 image = XGetImage( gdi_display, physDev->drawable,
1049 physDev->org.x + visRectDst->left,
1050 physDev->org.y + visRectDst->top,
1051 width, height, AllPlanes, ZPixmap );
1052 else
1053 {
1054 /* Make sure we don't get a BadMatch error */
1055 XCopyArea( gdi_display, physDev->drawable, pixmap, gc,
1056 physDev->org.x + visRectDst->left,
1057 physDev->org.y + visRectDst->top,
1058 width, height, 0, 0);
1059 exposures++;
1060 image = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1061 AllPlanes, ZPixmap );
1062 }
1063 for (y = 0; y < height; y++)
1064 for (x = 0; x < width; x++)
1065 XPutPixel( image, x, y,
1066 X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y )]);
1067 XPutImage( gdi_display, pixmap, gc, image, 0, 0, 0, 0, width, height );
1068 XDestroyImage( image );
1069 }
1070 return exposures;
1071 }
1072
1073
1074 /***********************************************************************
1075 * BITBLT_PutDstArea
1076 *
1077 * Put an area back into the destination DC, mapping the pixel
1078 * colors to X pixels.
1079 */
1080 static int BITBLT_PutDstArea(X11DRV_PDEVICE *physDev, Pixmap pixmap, RECT *visRectDst)
1081 {
1082 int exposures = 0;
1083 INT width = visRectDst->right - visRectDst->left;
1084 INT height = visRectDst->bottom - visRectDst->top;
1085
1086 /* !X11DRV_PALETTE_PaletteToXPixel is _NOT_ enough */
1087
1088 if (!X11DRV_PALETTE_PaletteToXPixel || (physDev->depth == 1) ||
1089 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) )
1090 {
1091 XCopyArea( gdi_display, pixmap, physDev->drawable, physDev->gc, 0, 0, width, height,
1092 physDev->org.x + visRectDst->left,
1093 physDev->org.y + visRectDst->top );
1094 exposures++;
1095 }
1096 else
1097 {
1098 register INT x, y;
1099 XImage *image = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1100 AllPlanes, ZPixmap );
1101 for (y = 0; y < height; y++)
1102 for (x = 0; x < width; x++)
1103 {
1104 XPutPixel( image, x, y,
1105 X11DRV_PALETTE_PaletteToXPixel[XGetPixel( image, x, y )]);
1106 }
1107 XPutImage( gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1108 physDev->org.x + visRectDst->left,
1109 physDev->org.y + visRectDst->top, width, height );
1110 XDestroyImage( image );
1111 }
1112 return exposures;
1113 }
1114
1115
1116 /***********************************************************************
1117 * BITBLT_GetVisRectangles
1118 *
1119 * Get the source and destination visible rectangles for StretchBlt().
1120 * Return FALSE if one of the rectangles is empty.
1121 */
1122 static BOOL BITBLT_GetVisRectangles( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1123 INT widthDst, INT heightDst,
1124 X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1125 INT widthSrc, INT heightSrc,
1126 RECT *visRectSrc, RECT *visRectDst )
1127 {
1128 RECT rect, clipRect;
1129
1130 /* Get the destination visible rectangle */
1131
1132 rect.left = xDst;
1133 rect.top = yDst;
1134 rect.right = xDst + widthDst;
1135 rect.bottom = yDst + heightDst;
1136 if (widthDst < 0) SWAP_INT32( &rect.left, &rect.right );
1137 if (heightDst < 0) SWAP_INT32( &rect.top, &rect.bottom );
1138 GetRgnBox( physDevDst->region, &clipRect );
1139 if (!IntersectRect( visRectDst, &rect, &clipRect )) return FALSE;
1140
1141 /* Get the source visible rectangle */
1142
1143 if (!physDevSrc) return TRUE;
1144 rect.left = xSrc;
1145 rect.top = ySrc;
1146 rect.right = xSrc + widthSrc;
1147 rect.bottom = ySrc + heightSrc;
1148 if (widthSrc < 0) SWAP_INT32( &rect.left, &rect.right );
1149 if (heightSrc < 0) SWAP_INT32( &rect.top, &rect.bottom );
1150 /* Apparently the clipping and visible regions are only for output,
1151 so just check against dc extent here to avoid BadMatch errors */
1152 if (physDevSrc->bitmap)
1153 {
1154 BITMAP bm;
1155 GetObjectW( physDevSrc->bitmap->hbitmap, sizeof(bm), &bm );
1156 SetRect( &clipRect, 0, 0, bm.bmWidth, bm.bmHeight );
1157 }
1158 else clipRect = virtual_screen_rect;
1159 if (!IntersectRect( visRectSrc, &rect, &clipRect ))
1160 return FALSE;
1161
1162 /* Intersect the rectangles */
1163
1164 if ((widthSrc == widthDst) && (heightSrc == heightDst)) /* no stretching */
1165 {
1166 visRectSrc->left += xDst - xSrc;
1167 visRectSrc->right += xDst - xSrc;
1168 visRectSrc->top += yDst - ySrc;
1169 visRectSrc->bottom += yDst - ySrc;
1170 if (!IntersectRect( &rect, visRectSrc, visRectDst )) return FALSE;
1171 *visRectSrc = *visRectDst = rect;
1172 visRectSrc->left += xSrc - xDst;
1173 visRectSrc->right += xSrc - xDst;
1174 visRectSrc->top += ySrc - yDst;
1175 visRectSrc->bottom += ySrc - yDst;
1176 }
1177 else /* stretching */
1178 {
1179 /* Map source rectangle into destination coordinates */
1180 rect.left = xDst + (visRectSrc->left - xSrc)*widthDst/widthSrc;
1181 rect.top = yDst + (visRectSrc->top - ySrc)*heightDst/heightSrc;
1182 rect.right = xDst + ((visRectSrc->right - xSrc)*widthDst)/widthSrc;
1183 rect.bottom = yDst + ((visRectSrc->bottom - ySrc)*heightDst)/heightSrc;
1184 if (rect.left > rect.right) SWAP_INT32( &rect.left, &rect.right );
1185 if (rect.top > rect.bottom) SWAP_INT32( &rect.top, &rect.bottom );
1186
1187 /* Avoid rounding errors */
1188 rect.left--;
1189 rect.top--;
1190 rect.right++;
1191 rect.bottom++;
1192 if (!IntersectRect( visRectDst, &rect, visRectDst )) return FALSE;
1193
1194 /* Map destination rectangle back to source coordinates */
1195 rect = *visRectDst;
1196 rect.left = xSrc + (visRectDst->left - xDst)*widthSrc/widthDst;
1197 rect.top = ySrc + (visRectDst->top - yDst)*heightSrc/heightDst;
1198 rect.right = xSrc + ((visRectDst->right - xDst)*widthSrc)/widthDst;
1199 rect.bottom = ySrc + ((visRectDst->bottom - yDst)*heightSrc)/heightDst;
1200 if (rect.left > rect.right) SWAP_INT32( &rect.left, &rect.right );
1201 if (rect.top > rect.bottom) SWAP_INT32( &rect.top, &rect.bottom );
1202
1203 /* Avoid rounding errors */
1204 rect.left--;
1205 rect.top--;
1206 rect.right++;
1207 rect.bottom++;
1208 if (!IntersectRect( visRectSrc, &rect, visRectSrc )) return FALSE;
1209 }
1210 return TRUE;
1211 }
1212
1213
1214 /***********************************************************************
1215 * BITBLT_InternalStretchBlt
1216 *
1217 * Implementation of PatBlt(), BitBlt() and StretchBlt().
1218 */
1219 static BOOL BITBLT_InternalStretchBlt( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1220 INT widthDst, INT heightDst,
1221 X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1222 INT widthSrc, INT heightSrc,
1223 DWORD rop )
1224 {
1225 BOOL usePat, useSrc, useDst, destUsed, fStretch, fNullBrush;
1226 RECT visRectDst, visRectSrc;
1227 INT width, height;
1228 const BYTE *opcode;
1229 Pixmap pixmaps[3] = { 0, 0, 0 }; /* pixmaps for DST, SRC, TMP */
1230 GC tmpGC = 0;
1231 POINT pts[2];
1232
1233 /* compensate for off-by-one shifting for negative widths and heights */
1234 if (widthDst < 0)
1235 ++xDst;
1236 if (heightDst < 0)
1237 ++yDst;
1238 if (widthSrc < 0)
1239 ++xSrc;
1240 if (heightSrc < 0)
1241 ++ySrc;
1242
1243 usePat = (((rop >> 4) & 0x0f0000) != (rop & 0x0f0000));
1244 useSrc = (((rop >> 2) & 0x330000) != (rop & 0x330000));
1245 useDst = (((rop >> 1) & 0x550000) != (rop & 0x550000));
1246 if (!physDevSrc && useSrc) return FALSE;
1247
1248 /* Map the coordinates to device coords */
1249
1250 pts[0].x = xDst;
1251 pts[0].y = yDst;
1252 pts[1].x = xDst + widthDst;
1253 pts[1].y = yDst + heightDst;
1254 LPtoDP(physDevDst->hdc, pts, 2);
1255 xDst = pts[0].x;
1256 yDst = pts[0].y;
1257 widthDst = pts[1].x - pts[0].x;
1258 heightDst = pts[1].y - pts[0].y;
1259
1260 TRACE(" rectdst=%d,%d-%d,%d orgdst=%d,%d\n",
1261 xDst, yDst, widthDst, heightDst,
1262 physDevDst->org.x, physDevDst->org.y );
1263
1264 if (useSrc)
1265 {
1266 pts[0].x = xSrc;
1267 pts[0].y = ySrc;
1268 pts[1].x = xSrc + widthSrc;
1269 pts[1].y = ySrc + heightSrc;
1270 LPtoDP(physDevSrc->hdc, pts, 2);
1271 xSrc = pts[0].x;
1272 ySrc = pts[0].y;
1273 widthSrc = pts[1].x - pts[0].x;
1274 heightSrc = pts[1].y - pts[0].y;
1275
1276 fStretch = (widthSrc != widthDst) || (heightSrc != heightDst);
1277 TRACE(" rectsrc=%d,%d-%d,%d orgsrc=%d,%d\n",
1278 xSrc, ySrc, widthSrc, heightSrc,
1279 physDevSrc->org.x, physDevSrc->org.y );
1280 if (!BITBLT_GetVisRectangles( physDevDst, xDst, yDst, widthDst, heightDst,
1281 physDevSrc, xSrc, ySrc, widthSrc, heightSrc,
1282 &visRectSrc, &visRectDst ))
1283 return TRUE;
1284 TRACE(" vissrc=%d,%d-%d,%d visdst=%d,%d-%d,%d\n",
1285 visRectSrc.left, visRectSrc.top,
1286 visRectSrc.right, visRectSrc.bottom,
1287 visRectDst.left, visRectDst.top,
1288 visRectDst.right, visRectDst.bottom );
1289 }
1290 else
1291 {
1292 fStretch = FALSE;
1293 if (!BITBLT_GetVisRectangles( physDevDst, xDst, yDst, widthDst, heightDst,
1294 NULL, 0, 0, 0, 0, NULL, &visRectDst ))
1295 return TRUE;
1296 TRACE(" vissrc=none visdst=%d,%d-%d,%d\n",
1297 visRectDst.left, visRectDst.top,
1298 visRectDst.right, visRectDst.bottom );
1299 }
1300
1301 width = visRectDst.right - visRectDst.left;
1302 height = visRectDst.bottom - visRectDst.top;
1303
1304 if (!fStretch) switch(rop) /* A few optimisations */
1305 {
1306 case BLACKNESS: /* 0x00 */
1307 wine_tsx11_lock();
1308 if ((physDevDst->depth == 1) || !X11DRV_PALETTE_PaletteToXPixel)
1309 XSetFunction( gdi_display, physDevDst->gc, GXclear );
1310 else
1311 {
1312 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1313 XSetForeground( gdi_display, physDevDst->gc, X11DRV_PALETTE_PaletteToXPixel[0] );
1314 XSetFillStyle( gdi_display, physDevDst->gc, FillSolid );
1315 }
1316 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1317 physDevDst->org.x + visRectDst.left,
1318 physDevDst->org.y + visRectDst.top,
1319 width, height );
1320 wine_tsx11_unlock();
1321 return TRUE;
1322
1323 case DSTINVERT: /* 0x55 */
1324 wine_tsx11_lock();
1325 XSetFunction( gdi_display, physDevDst->gc, GXinvert );
1326
1327 if( X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_PRIVATE | X11DRV_PALETTE_VIRTUAL) )
1328 XSetFunction( gdi_display, physDevDst->gc, GXinvert);
1329 else
1330 {
1331 /* Xor is much better when we do not have full colormap. */
1332 /* Using white^black ensures that we invert at least black */
1333 /* and white. */
1334 unsigned long xor_pix = (WhitePixel( gdi_display, DefaultScreen(gdi_display) ) ^
1335 BlackPixel( gdi_display, DefaultScreen(gdi_display) ));
1336 XSetFunction( gdi_display, physDevDst->gc, GXxor );
1337 XSetForeground( gdi_display, physDevDst->gc, xor_pix);
1338 XSetFillStyle( gdi_display, physDevDst->gc, FillSolid );
1339 }
1340 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1341 physDevDst->org.x + visRectDst.left,
1342 physDevDst->org.y + visRectDst.top,
1343 width, height );
1344 wine_tsx11_unlock();
1345 return TRUE;
1346
1347 case PATINVERT: /* 0x5a */
1348 if (X11DRV_SetupGCForBrush( physDevDst ))
1349 {
1350 wine_tsx11_lock();
1351 XSetFunction( gdi_display, physDevDst->gc, GXxor );
1352 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1353 physDevDst->org.x + visRectDst.left,
1354 physDevDst->org.y + visRectDst.top,
1355 width, height );
1356 wine_tsx11_unlock();
1357 }
1358 return TRUE;
1359
1360 case 0xa50065:
1361 if (X11DRV_SetupGCForBrush( physDevDst ))
1362 {
1363 wine_tsx11_lock();
1364 XSetFunction( gdi_display, physDevDst->gc, GXequiv );
1365 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1366 physDevDst->org.x + visRectDst.left,
1367 physDevDst->org.y + visRectDst.top,
1368 width, height );
1369 wine_tsx11_unlock();
1370 }
1371 return TRUE;
1372
1373 case SRCCOPY: /* 0xcc */
1374 if (physDevSrc->depth == physDevDst->depth)
1375 {
1376 wine_tsx11_lock();
1377 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1378 XCopyArea( gdi_display, physDevSrc->drawable,
1379 physDevDst->drawable, physDevDst->gc,
1380 physDevSrc->org.x + visRectSrc.left,
1381 physDevSrc->org.y + visRectSrc.top,
1382 width, height,
1383 physDevDst->org.x + visRectDst.left,
1384 physDevDst->org.y + visRectDst.top );
1385 physDevDst->exposures++;
1386 wine_tsx11_unlock();
1387 return TRUE;
1388 }
1389
1390 if (physDevSrc->depth == 1)
1391 {
1392 int fg, bg;
1393 get_colors(physDevDst, physDevSrc, &fg, &bg);
1394 wine_tsx11_lock();
1395
1396 XSetBackground( gdi_display, physDevDst->gc, fg );
1397 XSetForeground( gdi_display, physDevDst->gc, bg );
1398 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1399 XCopyPlane( gdi_display, physDevSrc->drawable,
1400 physDevDst->drawable, physDevDst->gc,
1401 physDevSrc->org.x + visRectSrc.left,
1402 physDevSrc->org.y + visRectSrc.top,
1403 width, height,
1404 physDevDst->org.x + visRectDst.left,
1405 physDevDst->org.y + visRectDst.top, 1 );
1406 physDevDst->exposures++;
1407 wine_tsx11_unlock();
1408 return TRUE;
1409 }
1410 break;
1411
1412 case PATCOPY: /* 0xf0 */
1413 if (!X11DRV_SetupGCForBrush( physDevDst )) return TRUE;
1414 wine_tsx11_lock();
1415 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1416 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1417 physDevDst->org.x + visRectDst.left,
1418 physDevDst->org.y + visRectDst.top,
1419 width, height );
1420 wine_tsx11_unlock();
1421 return TRUE;
1422
1423 case WHITENESS: /* 0xff */
1424 wine_tsx11_lock();
1425 if ((physDevDst->depth == 1) || !X11DRV_PALETTE_PaletteToXPixel)
1426 XSetFunction( gdi_display, physDevDst->gc, GXset );
1427 else
1428 {
1429 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1430 XSetForeground( gdi_display, physDevDst->gc,
1431 WhitePixel( gdi_display, DefaultScreen(gdi_display) ));
1432 XSetFillStyle( gdi_display, physDevDst->gc, FillSolid );
1433 }
1434 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1435 physDevDst->org.x + visRectDst.left,
1436 physDevDst->org.y + visRectDst.top,
1437 width, height );
1438 wine_tsx11_unlock();
1439 return TRUE;
1440 }
1441
1442 wine_tsx11_lock();
1443
1444 tmpGC = XCreateGC( gdi_display, physDevDst->drawable, 0, NULL );
1445 XSetSubwindowMode( gdi_display, tmpGC, IncludeInferiors );
1446 XSetGraphicsExposures( gdi_display, tmpGC, False );
1447 pixmaps[DST] = XCreatePixmap( gdi_display, root_window, width, height,
1448 physDevDst->depth );
1449 if (useSrc)
1450 {
1451 pixmaps[SRC] = XCreatePixmap( gdi_display, root_window, width, height,
1452 physDevDst->depth );
1453 if (fStretch)
1454 BITBLT_GetSrcAreaStretch( physDevSrc, physDevDst, pixmaps[SRC], tmpGC,
1455 xSrc, ySrc, widthSrc, heightSrc,
1456 xDst, yDst, widthDst, heightDst,
1457 &visRectSrc, &visRectDst );
1458 else
1459 BITBLT_GetSrcArea( physDevSrc, physDevDst, pixmaps[SRC], tmpGC,
1460 xSrc, ySrc, &visRectSrc );
1461 }
1462
1463 if (useDst) BITBLT_GetDstArea( physDevDst, pixmaps[DST], tmpGC, &visRectDst );
1464 if (usePat) fNullBrush = !X11DRV_SetupGCForPatBlt( physDevDst, tmpGC, TRUE );
1465 else fNullBrush = FALSE;
1466 destUsed = FALSE;
1467
1468 for (opcode = BITBLT_Opcodes[(rop >> 16) & 0xff]; *opcode; opcode++)
1469 {
1470 if (OP_DST(*opcode) == DST) destUsed = TRUE;
1471 XSetFunction( gdi_display, tmpGC, OP_ROP(*opcode) );
1472 switch(OP_SRCDST(*opcode))
1473 {
1474 case OP_ARGS(DST,TMP):
1475 case OP_ARGS(SRC,TMP):
1476 if (!pixmaps[TMP])
1477 pixmaps[TMP] = XCreatePixmap( gdi_display, root_window,
1478 width, height, physDevDst->depth );
1479 /* fall through */
1480 case OP_ARGS(DST,SRC):
1481 case OP_ARGS(SRC,DST):
1482 case OP_ARGS(TMP,SRC):
1483 case OP_ARGS(TMP,DST):
1484 if (useSrc)
1485 XCopyArea( gdi_display, pixmaps[OP_SRC(*opcode)],
1486 pixmaps[OP_DST(*opcode)], tmpGC,
1487 0, 0, width, height, 0, 0 );
1488 break;
1489
1490 case OP_ARGS(PAT,TMP):
1491 if (!pixmaps[TMP] && !fNullBrush)
1492 pixmaps[TMP] = XCreatePixmap( gdi_display, root_window,
1493 width, height, physDevDst->depth );
1494 /* fall through */
1495 case OP_ARGS(PAT,DST):
1496 case OP_ARGS(PAT,SRC):
1497 if (!fNullBrush)
1498 XFillRectangle( gdi_display, pixmaps[OP_DST(*opcode)],
1499 tmpGC, 0, 0, width, height );
1500 break;
1501 }
1502 }
1503 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1504 physDevDst->exposures += BITBLT_PutDstArea( physDevDst, pixmaps[destUsed ? DST : SRC],
1505 &visRectDst );
1506 XFreePixmap( gdi_display, pixmaps[DST] );
1507 if (pixmaps[SRC]) XFreePixmap( gdi_display, pixmaps[SRC] );
1508 if (pixmaps[TMP]) XFreePixmap( gdi_display, pixmaps[TMP] );
1509 XFreeGC( gdi_display, tmpGC );
1510 wine_tsx11_unlock();
1511 return TRUE;
1512 }
1513
1514
1515 /***********************************************************************
1516 * X11DRV_PatBlt
1517 */
1518 BOOL X11DRV_PatBlt( X11DRV_PDEVICE *physDev, INT left, INT top, INT width, INT height, DWORD rop )
1519 {
1520 BOOL result;
1521
1522 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod, FALSE );
1523 result = BITBLT_InternalStretchBlt( physDev, left, top, width, height, NULL, 0, 0, 0, 0, rop );
1524 X11DRV_UnlockDIBSection( physDev, TRUE );
1525 return result;
1526 }
1527
1528
1529 /***********************************************************************
1530 * X11DRV_ClientSideDIBCopy
1531 */
1532 static BOOL X11DRV_ClientSideDIBCopy( X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1533 X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1534 INT width, INT height )
1535 {
1536 DIBSECTION srcDib, dstDib;
1537 BYTE *srcPtr, *dstPtr;
1538 INT bytesPerPixel;
1539 INT bytesToCopy;
1540 INT y;
1541 static RECT unusedRect;
1542
1543 if (GetObjectW(physDevSrc->bitmap->hbitmap, sizeof(srcDib), &srcDib) != sizeof(srcDib))
1544 return FALSE;
1545 if (GetObjectW(physDevDst->bitmap->hbitmap, sizeof(dstDib), &dstDib) != sizeof(dstDib))
1546 return FALSE;
1547
1548 /* check for oversized values, just like X11DRV_DIB_CopyDIBSection() */
1549 if (xSrc > srcDib.dsBm.bmWidth || ySrc > srcDib.dsBm.bmHeight)
1550 return FALSE;
1551 if (xSrc + width > srcDib.dsBm.bmWidth)
1552 width = srcDib.dsBm.bmWidth - xSrc;
1553 if (ySrc + height > srcDib.dsBm.bmHeight)
1554 height = srcDib.dsBm.bmHeight - ySrc;
1555
1556 if (GetRgnBox(physDevSrc->region, &unusedRect) == COMPLEXREGION ||
1557 GetRgnBox(physDevDst->region, &unusedRect) == COMPLEXREGION)
1558 {
1559 /* for simple regions, the clipping was already done by BITBLT_GetVisRectangles */
1560 FIXME("potential optimization: client-side complex region clipping\n");
1561 return FALSE;
1562 }
1563 if (dstDib.dsBm.bmBitsPixel <= 8)
1564 {
1565 FIXME("potential optimization: client-side color-index mode DIB copy\n");
1566 return FALSE;
1567 }
1568 if (!(srcDib.dsBmih.biCompression == BI_BITFIELDS &&
1569 dstDib.dsBmih.biCompression == BI_BITFIELDS &&
1570 !memcmp(srcDib.dsBitfields, dstDib.dsBitfields, 3*sizeof(DWORD)))
1571 && !(srcDib.dsBmih.biCompression == BI_RGB &&
1572 dstDib.dsBmih.biCompression == BI_RGB))
1573 {
1574 FIXME("potential optimization: client-side compressed DIB copy\n");
1575 return FALSE;
1576 }
1577 if (srcDib.dsBmih.biHeight < 0 || dstDib.dsBmih.biHeight < 0)
1578 {
1579 FIXME("potential optimization: client-side bottom-up DIB copy\n");
1580 return FALSE;
1581 }
1582
1583 switch (dstDib.dsBm.bmBitsPixel)
1584 {
1585 case 15:
1586 case 16:
1587 bytesPerPixel = 2;
1588 break;
1589 case 24:
1590 bytesPerPixel = 3;
1591 break;
1592 case 32:
1593 bytesPerPixel = 4;
1594 break;
1595 default:
1596 FIXME("don't know how to work with a depth of %d\n", physDevSrc->depth);
1597 return FALSE;
1598 }
1599
1600 bytesToCopy = width * bytesPerPixel;
1601
1602 srcPtr = &physDevSrc->bitmap->base[ySrc*srcDib.dsBm.bmWidthBytes + xSrc*bytesPerPixel];
1603 dstPtr = &physDevDst->bitmap->base[yDst*dstDib.dsBm.bmWidthBytes + xDst*bytesPerPixel];
1604
1605 for (y = yDst; y < yDst + height; ++y)
1606 {
1607 memcpy(dstPtr, srcPtr, bytesToCopy);
1608 srcPtr += srcDib.dsBm.bmWidthBytes;
1609 dstPtr += dstDib.dsBm.bmWidthBytes;
1610 }
1611
1612 return TRUE;
1613 }
1614
1615
1616 /***********************************************************************
1617 * X11DRV_BitBlt
1618 */
1619 BOOL X11DRV_BitBlt( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1620 INT width, INT height, X11DRV_PDEVICE *physDevSrc,
1621 INT xSrc, INT ySrc, DWORD rop )
1622 {
1623 BOOL result = FALSE;
1624 INT sSrc, sDst;
1625 RECT visRectDst, visRectSrc;
1626
1627 if (((rop >> 16) & 0x55) == ((rop >> 17) & 0x55)) {
1628 /* FIXME: seems the ROP doesn't include destination;
1629 * now if the destination area include the entire dcDst,
1630 * we can pass TRUE instead of FALSE to CoerceDIBSection(dcDst...),
1631 * which may avoid a copy in some situations */
1632 }
1633
1634 sDst = X11DRV_LockDIBSection( physDevDst, DIB_Status_None, FALSE );
1635 if (physDevDst != physDevSrc)
1636 sSrc = X11DRV_LockDIBSection( physDevSrc, DIB_Status_None, FALSE );
1637 else
1638 sSrc = sDst;
1639
1640 if ((sSrc == DIB_Status_AppMod) && (rop == SRCCOPY) &&
1641 (physDevSrc->depth == physDevDst->depth))
1642 {
1643 POINT pts[2];
1644 /* do everything ourselves; map coordinates */
1645
1646 pts[0].x = xSrc;
1647 pts[0].y = ySrc;
1648 pts[1].x = xSrc + width;
1649 pts[1].y = ySrc + height;
1650
1651 LPtoDP(physDevSrc->hdc, pts, 2);
1652 width = pts[1].x - pts[0].x;
1653 height = pts[1].y - pts[0].y;
1654 xSrc = pts[0].x;
1655 ySrc = pts[0].y;
1656
1657 pts[0].x = xDst;
1658 pts[0].y = yDst;
1659 LPtoDP(physDevDst->hdc, pts, 1);
1660
1661 xDst = pts[0].x;
1662 yDst = pts[0].y;
1663
1664 /* Perform basic clipping */
1665 if (!BITBLT_GetVisRectangles( physDevDst, xDst, yDst, width, height,
1666 physDevSrc, xSrc, ySrc, width, height,
1667 &visRectSrc, &visRectDst ))
1668 goto END;
1669
1670 xSrc = visRectSrc.left;
1671 ySrc = visRectSrc.top;
1672 xDst = visRectDst.left;
1673 yDst = visRectDst.top;
1674 width = visRectDst.right - visRectDst.left;
1675 height = visRectDst.bottom - visRectDst.top;
1676
1677 if (sDst == DIB_Status_AppMod) {
1678 result = X11DRV_ClientSideDIBCopy( physDevSrc, xSrc, ySrc,
1679 physDevDst, xDst, yDst,
1680 width, height );
1681 if (result)
1682 goto END;
1683 /* fall back to X server copying */
1684 }
1685 X11DRV_CoerceDIBSection( physDevDst, DIB_Status_GdiMod, FALSE );
1686
1687 wine_tsx11_lock();
1688 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1689 wine_tsx11_unlock();
1690
1691 X11DRV_DIB_CopyDIBSection( physDevSrc, physDevDst, xSrc, ySrc, xDst, yDst, width, height );
1692 result = TRUE;
1693 goto END;
1694 }
1695
1696 X11DRV_CoerceDIBSection( physDevDst, DIB_Status_GdiMod, FALSE );
1697 if (physDevDst != physDevSrc)
1698 X11DRV_CoerceDIBSection( physDevSrc, DIB_Status_GdiMod, FALSE );
1699
1700 result = BITBLT_InternalStretchBlt( physDevDst, xDst, yDst, width, height,
1701 physDevSrc, xSrc, ySrc, width, height, rop );
1702
1703 END:
1704 if (physDevDst != physDevSrc)
1705 X11DRV_UnlockDIBSection( physDevSrc, FALSE );
1706 X11DRV_UnlockDIBSection( physDevDst, TRUE );
1707
1708 return result;
1709 }
1710
1711
1712 /***********************************************************************
1713 * X11DRV_StretchBlt
1714 */
1715 BOOL X11DRV_StretchBlt( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1716 INT widthDst, INT heightDst,
1717 X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1718 INT widthSrc, INT heightSrc, DWORD rop )
1719 {
1720 BOOL result;
1721
1722 X11DRV_LockDIBSection( physDevDst, DIB_Status_GdiMod, FALSE );
1723 if (physDevDst != physDevSrc)
1724 X11DRV_LockDIBSection( physDevSrc, DIB_Status_GdiMod, FALSE );
1725
1726 result = BITBLT_InternalStretchBlt( physDevDst, xDst, yDst, widthDst, heightDst,
1727 physDevSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
1728
1729 if (physDevDst != physDevSrc)
1730 X11DRV_UnlockDIBSection( physDevSrc, FALSE );
1731 X11DRV_UnlockDIBSection( physDevDst, TRUE );
1732 return result;
1733 }
Maarten's multimedia branch