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