?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32: Delete the .windows-label file if the label is empty.
[wine/multimedia.git] / dlls / winex11.drv / bitblt.c
blobdcde11bae459c11b42a61dc6763e43364cb689a9
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 "winuser.h"
33 #include "x11drv.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(bitblt);
37
38
39 #define DST 0 /* Destination drawable */
40 #define SRC 1 /* Source drawable */
41 #define TMP 2 /* Temporary drawable */
42 #define PAT 3 /* Pattern (brush) in destination DC */
43
44 #define OP(src,dst,rop) (OP_ARGS(src,dst) << 4 | (rop))
45 #define OP_ARGS(src,dst) (((src) << 2) | (dst))
46
47 #define OP_SRC(opcode) ((opcode) >> 6)
48 #define OP_DST(opcode) (((opcode) >> 4) & 3)
49 #define OP_SRCDST(opcode) ((opcode) >> 4)
50 #define OP_ROP(opcode) ((opcode) & 0x0f)
51
52 #define MAX_OP_LEN 6 /* Longest opcode + 1 for the terminating 0 */
53
54 #define SWAP_INT32(i1,i2) \
55 do { INT __t = *(i1); *(i1) = *(i2); *(i2) = __t; } while(0)
56
57 static const unsigned char BITBLT_Opcodes[256][MAX_OP_LEN] =
58 {
59 { OP(PAT,DST,GXclear) }, /* 0x00 0 */
60 { OP(PAT,SRC,GXor), OP(SRC,DST,GXnor) }, /* 0x01 ~(D|(P|S)) */
61 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXand) }, /* 0x02 D&~(P|S) */
62 { OP(PAT,SRC,GXnor) }, /* 0x03 ~(P|S) */
63 { OP(PAT,DST,GXnor), OP(SRC,DST,GXand) }, /* 0x04 S&~(D|P) */
64 { OP(PAT,DST,GXnor) }, /* 0x05 ~(D|P) */
65 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXnor), }, /* 0x06 ~(P|~(D^S)) */
66 { OP(SRC,DST,GXand), OP(PAT,DST,GXnor) }, /* 0x07 ~(P|(D&S)) */
67 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXand) },/* 0x08 S&D&~P */
68 { OP(SRC,DST,GXxor), OP(PAT,DST,GXnor) }, /* 0x09 ~(P|(D^S)) */
69 { OP(PAT,DST,GXandInverted) }, /* 0x0a D&~P */
70 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXnor) }, /* 0x0b ~(P|(S&~D)) */
71 { OP(PAT,SRC,GXandInverted) }, /* 0x0c S&~P */
72 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXnor) },/* 0x0d ~(P|(D&~S)) */
73 { OP(SRC,DST,GXnor), OP(PAT,DST,GXnor) }, /* 0x0e ~(P|~(D|S)) */
74 { OP(PAT,DST,GXcopyInverted) }, /* 0x0f ~P */
75 { OP(SRC,DST,GXnor), OP(PAT,DST,GXand) }, /* 0x10 P&~(S|D) */
76 { OP(SRC,DST,GXnor) }, /* 0x11 ~(D|S) */
77 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXnor) }, /* 0x12 ~(S|~(D^P)) */
78 { OP(PAT,DST,GXand), OP(SRC,DST,GXnor) }, /* 0x13 ~(S|(D&P)) */
79 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXnor) }, /* 0x14 ~(D|~(P^S)) */
80 { OP(PAT,SRC,GXand), OP(SRC,DST,GXnor) }, /* 0x15 ~(D|(P&S)) */
81 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXnand),
82 OP(TMP,DST,GXand), OP(SRC,DST,GXxor),
83 OP(PAT,DST,GXxor) }, /* 0x16 P^S^(D&~(P&S) */
84 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
85 OP(PAT,SRC,GXxor), OP(SRC,DST,GXand),
86 OP(TMP,DST,GXequiv) }, /* 0x17 ~S^((S^P)&(S^D))*/
87 { OP(PAT,SRC,GXxor), OP(PAT,DST,GXxor),
88 OP(SRC,DST,GXand) }, /* 0x18 (S^P)&(D^P) */
89 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXnand),
90 OP(TMP,DST,GXand), OP(SRC,DST,GXequiv) }, /* 0x19 ~S^(D&~(P&S)) */
91 { OP(PAT,SRC,GXand), OP(SRC,DST,GXor),
92 OP(PAT,DST,GXxor) }, /* 0x1a P^(D|(S&P)) */
93 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXxor),
94 OP(TMP,DST,GXand), OP(SRC,DST,GXequiv) }, /* 0x1b ~S^(D&(P^S)) */
95 { OP(PAT,DST,GXand), OP(SRC,DST,GXor),
96 OP(PAT,DST,GXxor) }, /* 0x1c P^(S|(D&P)) */
97 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
98 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x1d ~D^(S&(D^P)) */
99 { OP(SRC,DST,GXor), OP(PAT,DST,GXxor) }, /* 0x1e P^(D|S) */
100 { OP(SRC,DST,GXor), OP(PAT,DST,GXnand) }, /* 0x1f ~(P&(D|S)) */
101 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXand) }, /* 0x20 D&(P&~S) */
102 { OP(PAT,DST,GXxor), OP(SRC,DST,GXnor) }, /* 0x21 ~(S|(D^P)) */
103 { OP(SRC,DST,GXandInverted) }, /* 0x22 ~S&D */
104 { OP(PAT,DST,GXandReverse), OP(SRC,DST,GXnor) }, /* 0x23 ~(S|(P&~D)) */
105 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
106 OP(SRC,DST,GXand) }, /* 0x24 (S^P)&(S^D) */
107 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXand),
108 OP(PAT,DST,GXequiv) }, /* 0x25 ~P^(D&~(S&P)) */
109 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXand),
110 OP(TMP,DST,GXor), OP(SRC,DST,GXxor) }, /* 0x26 S^(D|(S&P)) */
111 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXequiv),
112 OP(TMP,DST,GXor), OP(SRC,DST,GXxor) }, /* 0x27 S^(D|~(P^S)) */
113 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXand) }, /* 0x28 D&(P^S) */
114 { OP(SRC,TMP,GXcopy), OP(PAT,TMP,GXand),
115 OP(TMP,DST,GXor), OP(SRC,DST,GXxor),
116 OP(PAT,DST,GXequiv) }, /* 0x29 ~P^S^(D|(P&S)) */
117 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXand) }, /* 0x2a D&~(P&S) */
118 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
119 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
120 OP(TMP,DST,GXequiv) }, /* 0x2b ~S^((P^S)&(P^D))*/
121 { OP(SRC,DST,GXor), OP(PAT,DST,GXand),
122 OP(SRC,DST,GXxor) }, /* 0x2c S^(P&(S|D)) */
123 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXxor) }, /* 0x2d P^(S|~D) */
124 { OP(PAT,DST,GXxor), OP(SRC,DST,GXor),
125 OP(PAT,DST,GXxor) }, /* 0x2e P^(S|(D^P)) */
126 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXnand) }, /* 0x2f ~(P&(S|~D)) */
127 { OP(PAT,SRC,GXandReverse) }, /* 0x30 P&~S */
128 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXnor) },/* 0x31 ~(S|(D&~P)) */
129 { OP(SRC,DST,GXor), OP(PAT,DST,GXor),
130 OP(SRC,DST,GXxor) }, /* 0x32 S^(D|P|S) */
131 { OP(SRC,DST,GXcopyInverted) }, /* 0x33 ~S */
132 { OP(SRC,DST,GXand), OP(PAT,DST,GXor),
133 OP(SRC,DST,GXxor) }, /* 0x34 S^(P|(D&S)) */
134 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXor),
135 OP(SRC,DST,GXxor) }, /* 0x35 S^(P|~(D^S)) */
136 { OP(PAT,DST,GXor), OP(SRC,DST,GXxor) }, /* 0x36 S^(D|P) */
137 { OP(PAT,DST,GXor), OP(SRC,DST,GXnand) }, /* 0x37 ~(S&(D|P)) */
138 { OP(PAT,DST,GXor), OP(SRC,DST,GXand),
139 OP(PAT,DST,GXxor) }, /* 0x38 P^(S&(D|P)) */
140 { OP(PAT,DST,GXorReverse), OP(SRC,DST,GXxor) }, /* 0x39 S^(P|~D) */
141 { OP(SRC,DST,GXxor), OP(PAT,DST,GXor),
142 OP(SRC,DST,GXxor) }, /* 0x3a S^(P|(D^S)) */
143 { OP(PAT,DST,GXorReverse), OP(SRC,DST,GXnand) }, /* 0x3b ~(S&(P|~D)) */
144 { OP(PAT,SRC,GXxor) }, /* 0x3c P^S */
145 { OP(SRC,DST,GXnor), OP(PAT,DST,GXor),
146 OP(SRC,DST,GXxor) }, /* 0x3d S^(P|~(D|S)) */
147 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXor),
148 OP(SRC,DST,GXxor) }, /* 0x3e S^(P|(D&~S)) */
149 { OP(PAT,SRC,GXnand) }, /* 0x3f ~(P&S) */
150 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXand) }, /* 0x40 P&S&~D */
151 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXnor) }, /* 0x41 ~(D|(P^S)) */
152 { OP(DST,SRC,GXxor), OP(PAT,DST,GXxor),
153 OP(SRC,DST,GXand) }, /* 0x42 (S^D)&(P^D) */
154 { OP(SRC,DST,GXnand), OP(PAT,DST,GXand),
155 OP(SRC,DST,GXequiv) }, /* 0x43 ~S^(P&~(D&S)) */
156 { OP(SRC,DST,GXandReverse) }, /* 0x44 S&~D */
157 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXnor) }, /* 0x45 ~(D|(P&~S)) */
158 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
159 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x46 D^(S|(P&D)) */
160 { OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
161 OP(PAT,DST,GXequiv) }, /* 0x47 ~P^(S&(D^P)) */
162 { OP(PAT,DST,GXxor), OP(SRC,DST,GXand) }, /* 0x48 S&(P^D) */
163 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
164 OP(SRC,DST,GXor), OP(TMP,DST,GXxor),
165 OP(PAT,DST,GXequiv) }, /* 0x49 ~P^D^(S|(P&D)) */
166 { OP(DST,SRC,GXor), OP(PAT,SRC,GXand),
167 OP(SRC,DST,GXxor) }, /* 0x4a D^(P&(S|D)) */
168 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXxor) }, /* 0x4b P^(D|~S) */
169 { OP(PAT,DST,GXnand), OP(SRC,DST,GXand) }, /* 0x4c S&~(D&P) */
170 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
171 OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
172 OP(TMP,DST,GXequiv) }, /* 0x4d ~S^((S^P)|(S^D))*/
173 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
174 OP(PAT,DST,GXxor) }, /* 0x4e P^(D|(S^P)) */
175 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXnand) },/* 0x4f ~(P&(D|~S)) */
176 { OP(PAT,DST,GXandReverse) }, /* 0x50 P&~D */
177 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXnor) },/* 0x51 ~(D|(S&~P)) */
178 { OP(DST,SRC,GXand), OP(PAT,SRC,GXor),
179 OP(SRC,DST,GXxor) }, /* 0x52 D^(P|(S&D)) */
180 { OP(SRC,DST,GXxor), OP(PAT,DST,GXand),
181 OP(SRC,DST,GXequiv) }, /* 0x53 ~S^(P&(D^S)) */
182 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXnor) }, /* 0x54 ~(D|~(P|S)) */
183 { OP(PAT,DST,GXinvert) }, /* 0x55 ~D */
184 { OP(PAT,SRC,GXor), OP(SRC,DST,GXxor) }, /* 0x56 D^(P|S) */
185 { OP(PAT,SRC,GXor), OP(SRC,DST,GXnand) }, /* 0x57 ~(D&(P|S)) */
186 { OP(PAT,SRC,GXor), OP(SRC,DST,GXand),
187 OP(PAT,DST,GXxor) }, /* 0x58 P^(D&(P|S)) */
188 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXxor) }, /* 0x59 D^(P|~S) */
189 { OP(PAT,DST,GXxor) }, /* 0x5a D^P */
190 { OP(DST,SRC,GXnor), OP(PAT,SRC,GXor),
191 OP(SRC,DST,GXxor) }, /* 0x5b D^(P|~(S|D)) */
192 { OP(DST,SRC,GXxor), OP(PAT,SRC,GXor),
193 OP(SRC,DST,GXxor) }, /* 0x5c D^(P|(S^D)) */
194 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXnand) }, /* 0x5d ~(D&(P|~S)) */
195 { OP(DST,SRC,GXandInverted), OP(PAT,SRC,GXor),
196 OP(SRC,DST,GXxor) }, /* 0x5e D^(P|(S&~D)) */
197 { OP(PAT,DST,GXnand) }, /* 0x5f ~(D&P) */
198 { OP(SRC,DST,GXxor), OP(PAT,DST,GXand) }, /* 0x60 P&(D^S) */
199 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXand),
200 OP(PAT,DST,GXor), OP(SRC,DST,GXxor),
201 OP(TMP,DST,GXequiv) }, /* 0x61 ~D^S^(P|(D&S)) */
202 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
203 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0x62 D^(S&(P|D)) */
204 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXxor) }, /* 0x63 S^(D|~P) */
205 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
206 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0x64 S^(D&(P|S)) */
207 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXxor) }, /* 0x65 D^(S|~P) */
208 { OP(SRC,DST,GXxor) }, /* 0x66 S^D */
209 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnor),
210 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x67 S^(D|~(S|P) */
211 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXnor),
212 OP(PAT,DST,GXor), OP(SRC,DST,GXxor),
213 OP(TMP,DST,GXequiv) }, /* 0x68 ~D^S^(P|~(D|S))*/
214 { OP(SRC,DST,GXxor), OP(PAT,DST,GXequiv) }, /* 0x69 ~P^(D^S) */
215 { OP(PAT,SRC,GXand), OP(SRC,DST,GXxor) }, /* 0x6a D^(P&S) */
216 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
217 OP(SRC,DST,GXand), OP(TMP,DST,GXxor),
218 OP(PAT,DST,GXequiv) }, /* 0x6b ~P^S^(D&(P|S)) */
219 { OP(PAT,DST,GXand), OP(SRC,DST,GXxor) }, /* 0x6c S^(D&P) */
220 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
221 OP(SRC,DST,GXand), OP(TMP,DST,GXxor),
222 OP(PAT,DST,GXequiv) }, /* 0x6d ~P^D^(S&(P|D)) */
223 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXorReverse),
224 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0x6e S^(D&(P|~S)) */
225 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXnand) }, /* 0x6f ~(P&~(S^D)) */
226 { OP(SRC,DST,GXnand), OP(PAT,DST,GXand) }, /* 0x70 P&~(D&S) */
227 { OP(SRC,TMP,GXcopy), OP(DST,SRC,GXxor),
228 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
229 OP(TMP,DST,GXequiv) }, /* 0x71 ~S^((S^D)&(P^D))*/
230 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
231 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x72 S^(D|(P^S)) */
232 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXnand) },/* 0x73 ~(S&(D|~P)) */
233 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
234 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x74 D^(S|(P^D)) */
235 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXnand) },/* 0x75 ~(D&(S|~P)) */
236 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXandReverse),
237 OP(SRC,DST,GXor), OP(TMP,DST,GXxor) }, /* 0x76 S^(D|(P&~S)) */
238 { OP(SRC,DST,GXnand) }, /* 0x77 ~(S&D) */
239 { OP(SRC,DST,GXand), OP(PAT,DST,GXxor) }, /* 0x78 P^(D&S) */
240 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXor),
241 OP(PAT,DST,GXand), OP(SRC,DST,GXxor),
242 OP(TMP,DST,GXequiv) }, /* 0x79 ~D^S^(P&(D|S)) */
243 { OP(DST,SRC,GXorInverted), OP(PAT,SRC,GXand),
244 OP(SRC,DST,GXxor) }, /* 0x7a D^(P&(S|~D)) */
245 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXnand) }, /* 0x7b ~(S&~(D^P)) */
246 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXand),
247 OP(SRC,DST,GXxor) }, /* 0x7c S^(P&(D|~S)) */
248 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXnand) }, /* 0x7d ~(D&~(P^S)) */
249 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
250 OP(SRC,DST,GXor) }, /* 0x7e (S^P)|(S^D) */
251 { OP(PAT,SRC,GXand), OP(SRC,DST,GXnand) }, /* 0x7f ~(D&P&S) */
252 { OP(PAT,SRC,GXand), OP(SRC,DST,GXand) }, /* 0x80 D&P&S */
253 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
254 OP(SRC,DST,GXnor) }, /* 0x81 ~((S^P)|(S^D)) */
255 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXand) }, /* 0x82 D&~(P^S) */
256 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXand),
257 OP(SRC,DST,GXequiv) }, /* 0x83 ~S^(P&(D|~S)) */
258 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXand) }, /* 0x84 S&~(D^P) */
259 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXand),
260 OP(PAT,DST,GXequiv) }, /* 0x85 ~P^(D&(S|~P)) */
261 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXor),
262 OP(PAT,DST,GXand), OP(SRC,DST,GXxor),
263 OP(TMP,DST,GXxor) }, /* 0x86 D^S^(P&(D|S)) */
264 { OP(SRC,DST,GXand), OP(PAT,DST,GXequiv) }, /* 0x87 ~P^(D&S) */
265 { OP(SRC,DST,GXand) }, /* 0x88 S&D */
266 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXandReverse),
267 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x89 ~S^(D|(P&~S)) */
268 { OP(PAT,SRC,GXorInverted), OP(SRC,DST,GXand) }, /* 0x8a D&(S|~P) */
269 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
270 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x8b ~D^(S|(P^D)) */
271 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXand) }, /* 0x8c S&(D|~P) */
272 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
273 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x8d ~S^(D|(P^S)) */
274 { OP(SRC,TMP,GXcopy), OP(DST,SRC,GXxor),
275 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
276 OP(TMP,DST,GXxor) }, /* 0x8e S^((S^D)&(P^D))*/
277 { OP(SRC,DST,GXnand), OP(PAT,DST,GXnand) }, /* 0x8f ~(P&~(D&S)) */
278 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXand) }, /* 0x90 P&~(D^S) */
279 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXorReverse),
280 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x91 ~S^(D&(P|~S)) */
281 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
282 OP(SRC,DST,GXand), OP(PAT,DST,GXxor),
283 OP(TMP,DST,GXxor) }, /* 0x92 D^P^(S&(D|P)) */
284 { OP(PAT,DST,GXand), OP(SRC,DST,GXequiv) }, /* 0x93 ~S^(P&D) */
285 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
286 OP(SRC,DST,GXand), OP(PAT,DST,GXxor),
287 OP(TMP,DST,GXxor) }, /* 0x94 S^P^(D&(P|S)) */
288 { OP(PAT,SRC,GXand), OP(SRC,DST,GXequiv) }, /* 0x95 ~D^(P&S) */
289 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXxor) }, /* 0x96 D^P^S */
290 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnor),
291 OP(SRC,DST,GXor), OP(PAT,DST,GXxor),
292 OP(TMP,DST,GXxor) }, /* 0x97 S^P^(D|~(P|S)) */
293 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnor),
294 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0x98 ~S^(D|~(P|S)) */
295 { OP(SRC,DST,GXequiv) }, /* 0x99 ~S^D */
296 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXxor) }, /* 0x9a D^(P&~S) */
297 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXor),
298 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x9b ~S^(D&(P|S)) */
299 { OP(PAT,DST,GXandReverse), OP(SRC,DST,GXxor) }, /* 0x9c S^(P&~D) */
300 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXor),
301 OP(SRC,DST,GXand), OP(TMP,DST,GXequiv) }, /* 0x9d ~D^(S&(P|D)) */
302 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXand),
303 OP(PAT,DST,GXor), OP(SRC,DST,GXxor),
304 OP(TMP,DST,GXxor) }, /* 0x9e D^S^(P|(D&S)) */
305 { OP(SRC,DST,GXxor), OP(PAT,DST,GXnand) }, /* 0x9f ~(P&(D^S)) */
306 { OP(PAT,DST,GXand) }, /* 0xa0 D&P */
307 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXor),
308 OP(PAT,DST,GXequiv) }, /* 0xa1 ~P^(D|(S&~P)) */
309 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXand) }, /* 0xa2 D&(P|~S) */
310 { OP(DST,SRC,GXxor), OP(PAT,SRC,GXor),
311 OP(SRC,DST,GXequiv) }, /* 0xa3 ~D^(P|(S^D)) */
312 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXor),
313 OP(PAT,DST,GXequiv) }, /* 0xa4 ~P^(D|~(S|P)) */
314 { OP(PAT,DST,GXequiv) }, /* 0xa5 ~P^D */
315 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXxor) },/* 0xa6 D^(S&~P) */
316 { OP(PAT,SRC,GXor), OP(SRC,DST,GXand),
317 OP(PAT,DST,GXequiv) }, /* 0xa7 ~P^(D&(S|P)) */
318 { OP(PAT,SRC,GXor), OP(SRC,DST,GXand) }, /* 0xa8 D&(P|S) */
319 { OP(PAT,SRC,GXor), OP(SRC,DST,GXequiv) }, /* 0xa9 ~D^(P|S) */
320 { OP(PAT,DST,GXnoop) }, /* 0xaa D */
321 { OP(PAT,SRC,GXnor), OP(SRC,DST,GXor) }, /* 0xab D|~(P|S) */
322 { OP(SRC,DST,GXxor), OP(PAT,DST,GXand),
323 OP(SRC,DST,GXxor) }, /* 0xac S^(P&(D^S)) */
324 { OP(DST,SRC,GXand), OP(PAT,SRC,GXor),
325 OP(SRC,DST,GXequiv) }, /* 0xad ~D^(P|(S&D)) */
326 { OP(PAT,SRC,GXandInverted), OP(SRC,DST,GXor) }, /* 0xae D|(S&~P) */
327 { OP(PAT,DST,GXorInverted) }, /* 0xaf D|~P */
328 { OP(SRC,DST,GXorInverted), OP(PAT,DST,GXand) }, /* 0xb0 P&(D|~S) */
329 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
330 OP(PAT,DST,GXequiv) }, /* 0xb1 ~P^(D|(S^P)) */
331 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
332 OP(PAT,SRC,GXxor), OP(SRC,DST,GXor),
333 OP(TMP,DST,GXxor) }, /* 0xb2 S^((S^P)|(S^D))*/
334 { OP(PAT,DST,GXnand), OP(SRC,DST,GXnand) }, /* 0xb3 ~(S&~(D&P)) */
335 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXxor) }, /* 0xb4 P^(S&~D) */
336 { OP(DST,SRC,GXor), OP(PAT,SRC,GXand),
337 OP(SRC,DST,GXequiv) }, /* 0xb5 ~D^(P&(S|D)) */
338 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
339 OP(SRC,DST,GXor), OP(PAT,DST,GXxor),
340 OP(TMP,DST,GXxor) }, /* 0xb6 D^P^(S|(D&P)) */
341 { OP(PAT,DST,GXxor), OP(SRC,DST,GXnand) }, /* 0xb7 ~(S&(D^P)) */
342 { OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
343 OP(PAT,DST,GXxor) }, /* 0xb8 P^(S&(D^P)) */
344 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXand),
345 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0xb9 ~D^(S|(P&D)) */
346 { OP(PAT,SRC,GXandReverse), OP(SRC,DST,GXor) }, /* 0xba D|(P&~S) */
347 { OP(SRC,DST,GXorInverted) }, /* 0xbb ~S|D */
348 { OP(SRC,DST,GXnand), OP(PAT,DST,GXand),
349 OP(SRC,DST,GXxor) }, /* 0xbc S^(P&~(D&S)) */
350 { OP(DST,SRC,GXxor), OP(PAT,DST,GXxor),
351 OP(SRC,DST,GXnand) }, /* 0xbd ~((S^D)&(P^D)) */
352 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXor) }, /* 0xbe D|(P^S) */
353 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXor) }, /* 0xbf D|~(P&S) */
354 { OP(PAT,SRC,GXand) }, /* 0xc0 P&S */
355 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXor),
356 OP(SRC,DST,GXequiv) }, /* 0xc1 ~S^(P|(D&~S)) */
357 { OP(SRC,DST,GXnor), OP(PAT,DST,GXor),
358 OP(SRC,DST,GXequiv) }, /* 0xc2 ~S^(P|~(D|S)) */
359 { OP(PAT,SRC,GXequiv) }, /* 0xc3 ~P^S */
360 { OP(PAT,DST,GXorReverse), OP(SRC,DST,GXand) }, /* 0xc4 S&(P|~D) */
361 { OP(SRC,DST,GXxor), OP(PAT,DST,GXor),
362 OP(SRC,DST,GXequiv) }, /* 0xc5 ~S^(P|(D^S)) */
363 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXxor) },/* 0xc6 S^(D&~P) */
364 { OP(PAT,DST,GXor), OP(SRC,DST,GXand),
365 OP(PAT,DST,GXequiv) }, /* 0xc7 ~P^(S&(D|P)) */
366 { OP(PAT,DST,GXor), OP(SRC,DST,GXand) }, /* 0xc8 S&(D|P) */
367 { OP(PAT,DST,GXor), OP(SRC,DST,GXequiv) }, /* 0xc9 ~S^(P|D) */
368 { OP(DST,SRC,GXxor), OP(PAT,SRC,GXand),
369 OP(SRC,DST,GXxor) }, /* 0xca D^(P&(S^D)) */
370 { OP(SRC,DST,GXand), OP(PAT,DST,GXor),
371 OP(SRC,DST,GXequiv) }, /* 0xcb ~S^(P|(D&S)) */
372 { OP(SRC,DST,GXcopy) }, /* 0xcc S */
373 { OP(PAT,DST,GXnor), OP(SRC,DST,GXor) }, /* 0xcd S|~(D|P) */
374 { OP(PAT,DST,GXandInverted), OP(SRC,DST,GXor) }, /* 0xce S|(D&~P) */
375 { OP(PAT,SRC,GXorInverted) }, /* 0xcf S|~P */
376 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXand) }, /* 0xd0 P&(S|~D) */
377 { OP(PAT,DST,GXxor), OP(SRC,DST,GXor),
378 OP(PAT,DST,GXequiv) }, /* 0xd1 ~P^(S|(D^P)) */
379 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXxor) },/* 0xd2 P^(D&~S) */
380 { OP(SRC,DST,GXor), OP(PAT,DST,GXand),
381 OP(SRC,DST,GXequiv) }, /* 0xd3 ~S^(P&(D|S)) */
382 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
383 OP(PAT,DST,GXxor), OP(SRC,DST,GXand),
384 OP(TMP,DST,GXxor) }, /* 0xd4 S^((S^P)&(D^P))*/
385 { OP(PAT,SRC,GXnand), OP(SRC,DST,GXnand) }, /* 0xd5 ~(D&~(P&S)) */
386 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXand),
387 OP(SRC,DST,GXor), OP(PAT,DST,GXxor),
388 OP(TMP,DST,GXxor) }, /* 0xd6 S^P^(D|(P&S)) */
389 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXnand) }, /* 0xd7 ~(D&(P^S)) */
390 { OP(PAT,SRC,GXxor), OP(SRC,DST,GXand),
391 OP(PAT,DST,GXxor) }, /* 0xd8 P^(D&(S^P)) */
392 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXand),
393 OP(SRC,DST,GXor), OP(TMP,DST,GXequiv) }, /* 0xd9 ~S^(D|(P&S)) */
394 { OP(DST,SRC,GXnand), OP(PAT,SRC,GXand),
395 OP(SRC,DST,GXxor) }, /* 0xda D^(P&~(S&D)) */
396 { OP(SRC,DST,GXxor), OP(PAT,SRC,GXxor),
397 OP(SRC,DST,GXnand) }, /* 0xdb ~((S^P)&(S^D)) */
398 { OP(PAT,DST,GXandReverse), OP(SRC,DST,GXor) }, /* 0xdc S|(P&~D) */
399 { OP(SRC,DST,GXorReverse) }, /* 0xdd S|~D */
400 { OP(PAT,DST,GXxor), OP(SRC,DST,GXor) }, /* 0xde S|(D^P) */
401 { OP(PAT,DST,GXnand), OP(SRC,DST,GXor) }, /* 0xdf S|~(D&P) */
402 { OP(SRC,DST,GXor), OP(PAT,DST,GXand) }, /* 0xe0 P&(D|S) */
403 { OP(SRC,DST,GXor), OP(PAT,DST,GXequiv) }, /* 0xe1 ~P^(D|S) */
404 { OP(DST,TMP,GXcopy), OP(PAT,DST,GXxor),
405 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0xe2 D^(S&(P^D)) */
406 { OP(PAT,DST,GXand), OP(SRC,DST,GXor),
407 OP(PAT,DST,GXequiv) }, /* 0xe3 ~P^(S|(D&P)) */
408 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXxor),
409 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0xe4 S^(D&(P^S)) */
410 { OP(PAT,SRC,GXand), OP(SRC,DST,GXor),
411 OP(PAT,DST,GXequiv) }, /* 0xe5 ~P^(D|(S&P)) */
412 { OP(SRC,TMP,GXcopy), OP(PAT,SRC,GXnand),
413 OP(SRC,DST,GXand), OP(TMP,DST,GXxor) }, /* 0xe6 S^(D&~(P&S)) */
414 { OP(PAT,SRC,GXxor), OP(PAT,DST,GXxor),
415 OP(SRC,DST,GXnand) }, /* 0xe7 ~((S^P)&(D^P)) */
416 { OP(SRC,TMP,GXcopy), OP(SRC,DST,GXxor),
417 OP(PAT,SRC,GXxor), OP(SRC,DST,GXand),
418 OP(TMP,DST,GXxor) }, /* 0xe8 S^((S^P)&(S^D))*/
419 { OP(DST,TMP,GXcopy), OP(SRC,DST,GXnand),
420 OP(PAT,DST,GXand), OP(SRC,DST,GXxor),
421 OP(TMP,DST,GXequiv) }, /* 0xe9 ~D^S^(P&~(S&D))*/
422 { OP(PAT,SRC,GXand), OP(SRC,DST,GXor) }, /* 0xea D|(P&S) */
423 { OP(PAT,SRC,GXequiv), OP(SRC,DST,GXor) }, /* 0xeb D|~(P^S) */
424 { OP(PAT,DST,GXand), OP(SRC,DST,GXor) }, /* 0xec S|(D&P) */
425 { OP(PAT,DST,GXequiv), OP(SRC,DST,GXor) }, /* 0xed S|~(D^P) */
426 { OP(SRC,DST,GXor) }, /* 0xee S|D */
427 { OP(PAT,DST,GXorInverted), OP(SRC,DST,GXor) }, /* 0xef S|D|~P */
428 { OP(PAT,DST,GXcopy) }, /* 0xf0 P */
429 { OP(SRC,DST,GXnor), OP(PAT,DST,GXor) }, /* 0xf1 P|~(D|S) */
430 { OP(SRC,DST,GXandInverted), OP(PAT,DST,GXor) }, /* 0xf2 P|(D&~S) */
431 { OP(PAT,SRC,GXorReverse) }, /* 0xf3 P|~S */
432 { OP(SRC,DST,GXandReverse), OP(PAT,DST,GXor) }, /* 0xf4 P|(S&~D) */
433 { OP(PAT,DST,GXorReverse) }, /* 0xf5 P|~D */
434 { OP(SRC,DST,GXxor), OP(PAT,DST,GXor) }, /* 0xf6 P|(D^S) */
435 { OP(SRC,DST,GXnand), OP(PAT,DST,GXor) }, /* 0xf7 P|~(S&D) */
436 { OP(SRC,DST,GXand), OP(PAT,DST,GXor) }, /* 0xf8 P|(D&S) */
437 { OP(SRC,DST,GXequiv), OP(PAT,DST,GXor) }, /* 0xf9 P|~(D^S) */
438 { OP(PAT,DST,GXor) }, /* 0xfa D|P */
439 { OP(PAT,SRC,GXorReverse), OP(SRC,DST,GXor) }, /* 0xfb D|P|~S */
440 { OP(PAT,SRC,GXor) }, /* 0xfc P|S */
441 { OP(SRC,DST,GXorReverse), OP(PAT,DST,GXor) }, /* 0xfd P|S|~D */
442 { OP(SRC,DST,GXor), OP(PAT,DST,GXor) }, /* 0xfe P|D|S */
443 { OP(PAT,DST,GXset) } /* 0xff 1 */
444 };
445
446
447 #ifdef BITBLT_TEST /* Opcodes test */
448
449 static int do_bitop( int s, int d, int rop )
450 {
451 int res;
452 switch(rop)
453 {
454 case GXclear: res = 0; break;
455 case GXand: res = s & d; break;
456 case GXandReverse: res = s & ~d; break;
457 case GXcopy: res = s; break;
458 case GXandInverted: res = ~s & d; break;
459 case GXnoop: res = d; break;
460 case GXxor: res = s ^ d; break;
461 case GXor: res = s | d; break;
462 case GXnor: res = ~(s | d); break;
463 case GXequiv: res = ~s ^ d; break;
464 case GXinvert: res = ~d; break;
465 case GXorReverse: res = s | ~d; break;
466 case GXcopyInverted: res = ~s; break;
467 case GXorInverted: res = ~s | d; break;
468 case GXnand: res = ~(s & d); break;
469 case GXset: res = 1; break;
470 }
471 return res & 1;
472 }
473
474 int main()
475 {
476 int rop, i, res, src, dst, pat, tmp, dstUsed;
477 const BYTE *opcode;
478
479 for (rop = 0; rop < 256; rop++)
480 {
481 res = dstUsed = 0;
482 for (i = 0; i < 8; i++)
483 {
484 pat = (i >> 2) & 1;
485 src = (i >> 1) & 1;
486 dst = i & 1;
487 for (opcode = BITBLT_Opcodes[rop]; *opcode; opcode++)
488 {
489 switch(*opcode >> 4)
490 {
491 case OP_ARGS(DST,TMP):
492 tmp = do_bitop( dst, tmp, *opcode & 0xf );
493 break;
494 case OP_ARGS(DST,SRC):
495 src = do_bitop( dst, src, *opcode & 0xf );
496 break;
497 case OP_ARGS(SRC,TMP):
498 tmp = do_bitop( src, tmp, *opcode & 0xf );
499 break;
500 case OP_ARGS(SRC,DST):
501 dst = do_bitop( src, dst, *opcode & 0xf );
502 dstUsed = 1;
503 break;
504 case OP_ARGS(PAT,TMP):
505 tmp = do_bitop( pat, tmp, *opcode & 0xf );
506 break;
507 case OP_ARGS(PAT,DST):
508 dst = do_bitop( pat, dst, *opcode & 0xf );
509 dstUsed = 1;
510 break;
511 case OP_ARGS(PAT,SRC):
512 src = do_bitop( pat, src, *opcode & 0xf );
513 break;
514 case OP_ARGS(TMP,DST):
515 dst = do_bitop( tmp, dst, *opcode & 0xf );
516 dstUsed = 1;
517 break;
518 case OP_ARGS(TMP,SRC):
519 src = do_bitop( tmp, src, *opcode & 0xf );
520 break;
521 default:
522 printf( "Invalid opcode %x\n", *opcode );
523 }
524 }
525 if (!dstUsed) dst = src;
526 if (dst) res |= 1 << i;
527 }
528 if (res != rop) printf( "%02x: ERROR, res=%02x\n", rop, res );
529 }
530
531 return 0;
532 }
533
534 #endif /* BITBLT_TEST */
535
536
537 static void get_colors(X11DRV_PDEVICE *physDevDst, X11DRV_PDEVICE *physDevSrc,
538 int *fg, int *bg)
539 {
540 RGBQUAD rgb[2];
541
542 *fg = physDevDst->textPixel;
543 *bg = physDevDst->backgroundPixel;
544 if(physDevSrc->depth == 1) {
545 if(GetDIBColorTable(physDevSrc->hdc, 0, 2, rgb) == 2) {
546 DWORD logcolor;
547 logcolor = RGB(rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue);
548 *fg = X11DRV_PALETTE_ToPhysical( physDevDst, logcolor );
549 logcolor = RGB(rgb[1].rgbRed, rgb[1].rgbGreen,rgb[1].rgbBlue);
550 *bg = X11DRV_PALETTE_ToPhysical( physDevDst, logcolor );
551 }
552 }
553 }
554
555 /***********************************************************************
556 * BITBLT_StretchRow
557 *
558 * Stretch a row of pixels. Helper function for BITBLT_StretchImage.
559 */
560 static void BITBLT_StretchRow( int *rowSrc, int *rowDst,
561 INT startDst, INT widthDst,
562 INT xinc, INT xoff, WORD mode )
563 {
564 register INT xsrc = xinc * startDst + xoff;
565 rowDst += startDst;
566 switch(mode)
567 {
568 case STRETCH_ANDSCANS:
569 for(; widthDst > 0; widthDst--, xsrc += xinc)
570 *rowDst++ &= rowSrc[xsrc >> 16];
571 break;
572 case STRETCH_ORSCANS:
573 for(; widthDst > 0; widthDst--, xsrc += xinc)
574 *rowDst++ |= rowSrc[xsrc >> 16];
575 break;
576 case STRETCH_DELETESCANS:
577 for(; widthDst > 0; widthDst--, xsrc += xinc)
578 *rowDst++ = rowSrc[xsrc >> 16];
579 break;
580 }
581 }
582
583
584 /***********************************************************************
585 * BITBLT_ShrinkRow
586 *
587 * Shrink a row of pixels. Helper function for BITBLT_StretchImage.
588 */
589 static void BITBLT_ShrinkRow( int *rowSrc, int *rowDst,
590 INT startSrc, INT widthSrc,
591 INT xinc, INT xoff, WORD mode )
592 {
593 register INT xdst = xinc * startSrc + xoff;
594 rowSrc += startSrc;
595 switch(mode)
596 {
597 case STRETCH_ORSCANS:
598 for(; widthSrc > 0; widthSrc--, xdst += xinc)
599 rowDst[xdst >> 16] |= *rowSrc++;
600 break;
601 case STRETCH_ANDSCANS:
602 for(; widthSrc > 0; widthSrc--, xdst += xinc)
603 rowDst[xdst >> 16] &= *rowSrc++;
604 break;
605 case STRETCH_DELETESCANS:
606 for(; widthSrc > 0; widthSrc--, xdst += xinc)
607 rowDst[xdst >> 16] = *rowSrc++;
608 break;
609 }
610 }
611
612
613 /***********************************************************************
614 * BITBLT_GetRow
615 *
616 * Retrieve a row from an image. Helper function for BITBLT_StretchImage.
617 */
618 static void BITBLT_GetRow( XImage *image, int *pdata, INT row,
619 INT start, INT width, INT depthDst,
620 int fg, int bg, BOOL swap)
621 {
622 register INT i;
623
624 assert( (row >= 0) && (row < image->height) );
625 assert( (start >= 0) && (width <= image->width) );
626
627 pdata += swap ? start+width-1 : start;
628 if (image->depth == depthDst) /* color -> color */
629 {
630 if (X11DRV_PALETTE_XPixelToPalette && (depthDst != 1))
631 if (swap) for (i = 0; i < width; i++)
632 *pdata-- = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )];
633 else for (i = 0; i < width; i++)
634 *pdata++ = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )];
635 else
636 if (swap) for (i = 0; i < width; i++)
637 *pdata-- = XGetPixel( image, i, row );
638 else for (i = 0; i < width; i++)
639 *pdata++ = XGetPixel( image, i, row );
640 }
641 else
642 {
643 if (image->depth == 1) /* monochrome -> color */
644 {
645 if (X11DRV_PALETTE_XPixelToPalette)
646 {
647 fg = X11DRV_PALETTE_XPixelToPalette[fg];
648 bg = X11DRV_PALETTE_XPixelToPalette[bg];
649 }
650 if (swap) for (i = 0; i < width; i++)
651 *pdata-- = XGetPixel( image, i, row ) ? bg : fg;
652 else for (i = 0; i < width; i++)
653 *pdata++ = XGetPixel( image, i, row ) ? bg : fg;
654 }
655 else /* color -> monochrome */
656 {
657 if (swap) for (i = 0; i < width; i++)
658 *pdata-- = (XGetPixel( image, i, row ) == bg) ? 1 : 0;
659 else for (i = 0; i < width; i++)
660 *pdata++ = (XGetPixel( image, i, row ) == bg) ? 1 : 0;
661 }
662 }
663 }
664
665
666 /***********************************************************************
667 * BITBLT_StretchImage
668 *
669 * Stretch an X image.
670 * FIXME: does not work for full 32-bit coordinates.
671 */
672 static void BITBLT_StretchImage( XImage *srcImage, XImage *dstImage,
673 INT widthSrc, INT heightSrc,
674 INT widthDst, INT heightDst,
675 RECT *visRectSrc, RECT *visRectDst,
676 int foreground, int background, WORD mode )
677 {
678 int *rowSrc, *rowDst, *pixel;
679 char *pdata;
680 INT xinc, xoff, yinc, ysrc, ydst;
681 register INT x, y;
682 BOOL hstretch, vstretch, hswap, vswap;
683
684 hswap = widthSrc * widthDst < 0;
685 vswap = heightSrc * heightDst < 0;
686 widthSrc = abs(widthSrc);
687 heightSrc = abs(heightSrc);
688 widthDst = abs(widthDst);
689 heightDst = abs(heightDst);
690
691 if (!(rowSrc = HeapAlloc( GetProcessHeap(), 0,
692 (widthSrc+widthDst)*sizeof(int) ))) return;
693 rowDst = rowSrc + widthSrc;
694
695 /* When stretching, all modes are the same, and DELETESCANS is faster */
696 if ((widthSrc < widthDst) && (heightSrc < heightDst))
697 mode = STRETCH_DELETESCANS;
698
699 if (mode == STRETCH_HALFTONE) /* FIXME */
700 mode = STRETCH_DELETESCANS;
701
702 if (mode != STRETCH_DELETESCANS)
703 memset( rowDst, (mode == STRETCH_ANDSCANS) ? 0xff : 0x00,
704 widthDst*sizeof(int) );
705
706 hstretch = (widthSrc < widthDst);
707 vstretch = (heightSrc < heightDst);
708
709 if (hstretch)
710 {
711 xinc = (widthSrc << 16) / widthDst;
712 xoff = ((widthSrc << 16) - (xinc * widthDst)) / 2;
713 }
714 else
715 {
716 xinc = ((int)widthDst << 16) / widthSrc;
717 xoff = ((widthDst << 16) - (xinc * widthSrc)) / 2;
718 }
719
720 wine_tsx11_lock();
721 if (vstretch)
722 {
723 yinc = (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 = (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 wine_tsx11_unlock();
841 HeapFree( GetProcessHeap(), 0, rowSrc );
842 }
843
844
845 /***********************************************************************
846 * BITBLT_GetSrcAreaStretch
847 *
848 * Retrieve an area from the source DC, stretching and mapping all the
849 * pixels to Windows colors.
850 */
851 static int BITBLT_GetSrcAreaStretch( X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
852 Pixmap pixmap, GC gc,
853 INT xSrc, INT ySrc,
854 INT widthSrc, INT heightSrc,
855 INT xDst, INT yDst,
856 INT widthDst, INT heightDst,
857 RECT *visRectSrc, RECT *visRectDst )
858 {
859 XImage *imageSrc, *imageDst;
860 RECT rectSrc = *visRectSrc;
861 RECT rectDst = *visRectDst;
862 int fg, bg;
863
864 if (widthSrc < 0) xSrc += widthSrc;
865 if (widthDst < 0) xDst += widthDst;
866 if (heightSrc < 0) ySrc += heightSrc;
867 if (heightDst < 0) yDst += heightDst;
868 rectSrc.left -= xSrc;
869 rectSrc.right -= xSrc;
870 rectSrc.top -= ySrc;
871 rectSrc.bottom -= ySrc;
872 rectDst.left -= xDst;
873 rectDst.right -= xDst;
874 rectDst.top -= yDst;
875 rectDst.bottom -= yDst;
876
877 get_colors(physDevDst, physDevSrc, &fg, &bg);
878 wine_tsx11_lock();
879 /* FIXME: avoid BadMatch errors */
880 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
881 physDevSrc->dc_rect.left + visRectSrc->left,
882 physDevSrc->dc_rect.top + visRectSrc->top,
883 visRectSrc->right - visRectSrc->left,
884 visRectSrc->bottom - visRectSrc->top,
885 AllPlanes, ZPixmap );
886 wine_tsx11_unlock();
887
888 imageDst = X11DRV_DIB_CreateXImage( rectDst.right - rectDst.left,
889 rectDst.bottom - rectDst.top, physDevDst->depth );
890 BITBLT_StretchImage( imageSrc, imageDst, widthSrc, heightSrc,
891 widthDst, heightDst, &rectSrc, &rectDst,
892 fg, physDevDst->depth != 1 ?
893 bg : physDevSrc->backgroundPixel,
894 GetStretchBltMode(physDevDst->hdc) );
895 wine_tsx11_lock();
896 XPutImage( gdi_display, pixmap, gc, imageDst, 0, 0, 0, 0,
897 rectDst.right - rectDst.left, rectDst.bottom - rectDst.top );
898 XDestroyImage( imageSrc );
899 X11DRV_DIB_DestroyXImage( imageDst );
900 wine_tsx11_unlock();
901 return 0; /* no exposure events generated */
902 }
903
904
905 /***********************************************************************
906 * BITBLT_GetSrcArea
907 *
908 * Retrieve an area from the source DC, mapping all the
909 * pixels to Windows colors.
910 */
911 static int BITBLT_GetSrcArea( X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
912 Pixmap pixmap, GC gc, RECT *visRectSrc )
913 {
914 XImage *imageSrc, *imageDst;
915 register INT x, y;
916 int exposures = 0;
917 INT width = visRectSrc->right - visRectSrc->left;
918 INT height = visRectSrc->bottom - visRectSrc->top;
919 int fg, bg;
920 BOOL memdc = (GetObjectType(physDevSrc->hdc) == OBJ_MEMDC);
921
922 if (physDevSrc->depth == physDevDst->depth)
923 {
924 wine_tsx11_lock();
925 if (!X11DRV_PALETTE_XPixelToPalette ||
926 (physDevDst->depth == 1)) /* monochrome -> monochrome */
927 {
928 if (physDevDst->depth == 1)
929 {
930 /* MSDN says if StretchBlt must convert a bitmap from monochrome
931 to color or vice versa, the foreground and background color of
932 the device context are used. In fact, it also applies to the
933 case when it is converted from mono to mono. */
934 XSetBackground( gdi_display, gc, physDevDst->textPixel );
935 XSetForeground( gdi_display, gc, physDevDst->backgroundPixel );
936 XCopyPlane( gdi_display, physDevSrc->drawable, pixmap, gc,
937 physDevSrc->dc_rect.left + visRectSrc->left,
938 physDevSrc->dc_rect.top + visRectSrc->top,
939 width, height, 0, 0, 1);
940 }
941 else
942 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc,
943 physDevSrc->dc_rect.left + visRectSrc->left,
944 physDevSrc->dc_rect.top + visRectSrc->top,
945 width, height, 0, 0);
946 exposures++;
947 }
948 else /* color -> color */
949 {
950 if (memdc)
951 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
952 physDevSrc->dc_rect.left + visRectSrc->left,
953 physDevSrc->dc_rect.top + visRectSrc->top,
954 width, height, AllPlanes, ZPixmap );
955 else
956 {
957 /* Make sure we don't get a BadMatch error */
958 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc,
959 physDevSrc->dc_rect.left + visRectSrc->left,
960 physDevSrc->dc_rect.top + visRectSrc->top,
961 width, height, 0, 0);
962 exposures++;
963 imageSrc = XGetImage( gdi_display, pixmap, 0, 0, width, height,
964 AllPlanes, ZPixmap );
965 }
966 for (y = 0; y < height; y++)
967 for (x = 0; x < width; x++)
968 XPutPixel(imageSrc, x, y,
969 X11DRV_PALETTE_XPixelToPalette[XGetPixel(imageSrc, x, y)]);
970 XPutImage( gdi_display, pixmap, gc, imageSrc,
971 0, 0, 0, 0, width, height );
972 XDestroyImage( imageSrc );
973 }
974 wine_tsx11_unlock();
975 }
976 else
977 {
978 if (physDevSrc->depth == 1) /* monochrome -> color */
979 {
980 get_colors(physDevDst, physDevSrc, &fg, &bg);
981
982 wine_tsx11_lock();
983 if (X11DRV_PALETTE_XPixelToPalette)
984 {
985 XSetBackground( gdi_display, gc,
986 X11DRV_PALETTE_XPixelToPalette[fg] );
987 XSetForeground( gdi_display, gc,
988 X11DRV_PALETTE_XPixelToPalette[bg]);
989 }
990 else
991 {
992 XSetBackground( gdi_display, gc, fg );
993 XSetForeground( gdi_display, gc, bg );
994 }
995 XCopyPlane( gdi_display, physDevSrc->drawable, pixmap, gc,
996 physDevSrc->dc_rect.left + visRectSrc->left,
997 physDevSrc->dc_rect.top + visRectSrc->top,
998 width, height, 0, 0, 1 );
999 exposures++;
1000 wine_tsx11_unlock();
1001 }
1002 else /* color -> monochrome */
1003 {
1004 wine_tsx11_lock();
1005 /* FIXME: avoid BadMatch error */
1006 imageSrc = XGetImage( gdi_display, physDevSrc->drawable,
1007 physDevSrc->dc_rect.left + visRectSrc->left,
1008 physDevSrc->dc_rect.top + visRectSrc->top,
1009 width, height, AllPlanes, ZPixmap );
1010 if (!imageSrc)
1011 {
1012 wine_tsx11_unlock();
1013 return exposures;
1014 }
1015 imageDst = X11DRV_DIB_CreateXImage( width, height, physDevDst->depth );
1016 if (!imageDst)
1017 {
1018 XDestroyImage(imageSrc);
1019 wine_tsx11_unlock();
1020 return exposures;
1021 }
1022 for (y = 0; y < height; y++)
1023 for (x = 0; x < width; x++)
1024 XPutPixel(imageDst, x, y, (XGetPixel(imageSrc,x,y) ==
1025 physDevSrc->backgroundPixel) );
1026 XPutImage( gdi_display, pixmap, gc, imageDst,
1027 0, 0, 0, 0, width, height );
1028 XDestroyImage( imageSrc );
1029 X11DRV_DIB_DestroyXImage( imageDst );
1030 wine_tsx11_unlock();
1031 }
1032 }
1033 return exposures;
1034 }
1035
1036
1037 /***********************************************************************
1038 * BITBLT_GetDstArea
1039 *
1040 * Retrieve an area from the destination DC, mapping all the
1041 * pixels to Windows colors.
1042 */
1043 static int BITBLT_GetDstArea(X11DRV_PDEVICE *physDev, Pixmap pixmap, GC gc, RECT *visRectDst)
1044 {
1045 int exposures = 0;
1046 INT width = visRectDst->right - visRectDst->left;
1047 INT height = visRectDst->bottom - visRectDst->top;
1048 BOOL memdc = (GetObjectType( physDev->hdc ) == OBJ_MEMDC);
1049
1050 wine_tsx11_lock();
1051
1052 if (!X11DRV_PALETTE_XPixelToPalette || (physDev->depth == 1) ||
1053 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) )
1054 {
1055 XCopyArea( gdi_display, physDev->drawable, pixmap, gc,
1056 physDev->dc_rect.left + visRectDst->left, physDev->dc_rect.top + visRectDst->top,
1057 width, height, 0, 0 );
1058 exposures++;
1059 }
1060 else
1061 {
1062 register INT x, y;
1063 XImage *image;
1064
1065 if (memdc)
1066 image = XGetImage( gdi_display, physDev->drawable,
1067 physDev->dc_rect.left + visRectDst->left,
1068 physDev->dc_rect.top + visRectDst->top,
1069 width, height, AllPlanes, ZPixmap );
1070 else
1071 {
1072 /* Make sure we don't get a BadMatch error */
1073 XCopyArea( gdi_display, physDev->drawable, pixmap, gc,
1074 physDev->dc_rect.left + visRectDst->left,
1075 physDev->dc_rect.top + visRectDst->top,
1076 width, height, 0, 0);
1077 exposures++;
1078 image = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1079 AllPlanes, ZPixmap );
1080 }
1081 if (image)
1082 {
1083 for (y = 0; y < height; y++)
1084 for (x = 0; x < width; x++)
1085 XPutPixel( image, x, y,
1086 X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y )]);
1087 XPutImage( gdi_display, pixmap, gc, image, 0, 0, 0, 0, width, height );
1088 XDestroyImage( image );
1089 }
1090 }
1091
1092 wine_tsx11_unlock();
1093 return exposures;
1094 }
1095
1096
1097 /***********************************************************************
1098 * BITBLT_PutDstArea
1099 *
1100 * Put an area back into the destination DC, mapping the pixel
1101 * colors to X pixels.
1102 */
1103 static int BITBLT_PutDstArea(X11DRV_PDEVICE *physDev, Pixmap pixmap, RECT *visRectDst)
1104 {
1105 int exposures = 0;
1106 INT width = visRectDst->right - visRectDst->left;
1107 INT height = visRectDst->bottom - visRectDst->top;
1108
1109 /* !X11DRV_PALETTE_PaletteToXPixel is _NOT_ enough */
1110
1111 if (!X11DRV_PALETTE_PaletteToXPixel || (physDev->depth == 1) ||
1112 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) )
1113 {
1114 XCopyArea( gdi_display, pixmap, physDev->drawable, physDev->gc, 0, 0, width, height,
1115 physDev->dc_rect.left + visRectDst->left,
1116 physDev->dc_rect.top + visRectDst->top );
1117 exposures++;
1118 }
1119 else
1120 {
1121 register INT x, y;
1122 XImage *image = XGetImage( gdi_display, pixmap, 0, 0, width, height,
1123 AllPlanes, ZPixmap );
1124 for (y = 0; y < height; y++)
1125 for (x = 0; x < width; x++)
1126 {
1127 XPutPixel( image, x, y,
1128 X11DRV_PALETTE_PaletteToXPixel[XGetPixel( image, x, y )]);
1129 }
1130 XPutImage( gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1131 physDev->dc_rect.left + visRectDst->left,
1132 physDev->dc_rect.top + visRectDst->top, width, height );
1133 XDestroyImage( image );
1134 }
1135 return exposures;
1136 }
1137
1138
1139 /***********************************************************************
1140 * BITBLT_GetVisRectangles
1141 *
1142 * Get the source and destination visible rectangles for StretchBlt().
1143 * Return FALSE if one of the rectangles is empty.
1144 */
1145 static BOOL BITBLT_GetVisRectangles( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1146 INT widthDst, INT heightDst,
1147 X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1148 INT widthSrc, INT heightSrc,
1149 RECT *visRectSrc, RECT *visRectDst )
1150 {
1151 RECT rect, clipRect;
1152
1153 /* Get the destination visible rectangle */
1154
1155 rect.left = xDst;
1156 rect.top = yDst;
1157 rect.right = xDst + widthDst;
1158 rect.bottom = yDst + heightDst;
1159 if (widthDst < 0) SWAP_INT32( &rect.left, &rect.right );
1160 if (heightDst < 0) SWAP_INT32( &rect.top, &rect.bottom );
1161 GetRgnBox( physDevDst->region, &clipRect );
1162 if (!IntersectRect( visRectDst, &rect, &clipRect )) return FALSE;
1163
1164 /* Get the source visible rectangle */
1165
1166 if (!physDevSrc) return TRUE;
1167 rect.left = xSrc;
1168 rect.top = ySrc;
1169 rect.right = xSrc + widthSrc;
1170 rect.bottom = ySrc + heightSrc;
1171 if (widthSrc < 0) SWAP_INT32( &rect.left, &rect.right );
1172 if (heightSrc < 0) SWAP_INT32( &rect.top, &rect.bottom );
1173 /* Apparently the clipping and visible regions are only for output,
1174 so just check against dc extent here to avoid BadMatch errors */
1175 clipRect = physDevSrc->drawable_rect;
1176 OffsetRect( &clipRect, -(physDevSrc->drawable_rect.left + physDevSrc->dc_rect.left),
1177 -(physDevSrc->drawable_rect.top + physDevSrc->dc_rect.top) );
1178 if (!IntersectRect( visRectSrc, &rect, &clipRect ))
1179 return FALSE;
1180
1181 /* Intersect the rectangles */
1182
1183 if ((widthSrc == widthDst) && (heightSrc == heightDst)) /* no stretching */
1184 {
1185 visRectSrc->left += xDst - xSrc;
1186 visRectSrc->right += xDst - xSrc;
1187 visRectSrc->top += yDst - ySrc;
1188 visRectSrc->bottom += yDst - ySrc;
1189 if (!IntersectRect( &rect, visRectSrc, visRectDst )) return FALSE;
1190 *visRectSrc = *visRectDst = rect;
1191 visRectSrc->left += xSrc - xDst;
1192 visRectSrc->right += xSrc - xDst;
1193 visRectSrc->top += ySrc - yDst;
1194 visRectSrc->bottom += ySrc - yDst;
1195 }
1196 else /* stretching */
1197 {
1198 /* Map source rectangle into destination coordinates */
1199 rect.left = xDst + (visRectSrc->left - xSrc)*widthDst/widthSrc;
1200 rect.top = yDst + (visRectSrc->top - ySrc)*heightDst/heightSrc;
1201 rect.right = xDst + ((visRectSrc->right - xSrc)*widthDst)/widthSrc;
1202 rect.bottom = yDst + ((visRectSrc->bottom - ySrc)*heightDst)/heightSrc;
1203 if (rect.left > rect.right) SWAP_INT32( &rect.left, &rect.right );
1204 if (rect.top > rect.bottom) SWAP_INT32( &rect.top, &rect.bottom );
1205
1206 /* Avoid rounding errors */
1207 rect.left--;
1208 rect.top--;
1209 rect.right++;
1210 rect.bottom++;
1211 if (!IntersectRect( visRectDst, &rect, visRectDst )) return FALSE;
1212
1213 /* Map destination rectangle back to source coordinates */
1214 rect = *visRectDst;
1215 rect.left = xSrc + (visRectDst->left - xDst)*widthSrc/widthDst;
1216 rect.top = ySrc + (visRectDst->top - yDst)*heightSrc/heightDst;
1217 rect.right = xSrc + ((visRectDst->right - xDst)*widthSrc)/widthDst;
1218 rect.bottom = ySrc + ((visRectDst->bottom - yDst)*heightSrc)/heightDst;
1219 if (rect.left > rect.right) SWAP_INT32( &rect.left, &rect.right );
1220 if (rect.top > rect.bottom) SWAP_INT32( &rect.top, &rect.bottom );
1221
1222 /* Avoid rounding errors */
1223 rect.left--;
1224 rect.top--;
1225 rect.right++;
1226 rect.bottom++;
1227 if (!IntersectRect( visRectSrc, &rect, visRectSrc )) return FALSE;
1228 }
1229 return TRUE;
1230 }
1231
1232
1233 /***********************************************************************
1234 * BITBLT_InternalStretchBlt
1235 *
1236 * Implementation of PatBlt(), BitBlt() and StretchBlt().
1237 */
1238 static BOOL BITBLT_InternalStretchBlt( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1239 INT widthDst, INT heightDst,
1240 X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1241 INT widthSrc, INT heightSrc,
1242 DWORD rop )
1243 {
1244 BOOL usePat, useSrc, useDst, destUsed, fStretch, fNullBrush;
1245 RECT visRectDst, visRectSrc;
1246 INT width, height;
1247 const BYTE *opcode;
1248 Pixmap pixmaps[3] = { 0, 0, 0 }; /* pixmaps for DST, SRC, TMP */
1249 GC tmpGC = 0;
1250 POINT pts[2];
1251
1252 /* compensate for off-by-one shifting for negative widths and heights */
1253 if (widthDst < 0)
1254 ++xDst;
1255 if (heightDst < 0)
1256 ++yDst;
1257 if (widthSrc < 0)
1258 ++xSrc;
1259 if (heightSrc < 0)
1260 ++ySrc;
1261
1262 usePat = (((rop >> 4) & 0x0f0000) != (rop & 0x0f0000));
1263 useSrc = (((rop >> 2) & 0x330000) != (rop & 0x330000));
1264 useDst = (((rop >> 1) & 0x550000) != (rop & 0x550000));
1265 if (!physDevSrc && useSrc) return FALSE;
1266
1267 /* Map the coordinates to device coords */
1268
1269 pts[0].x = xDst;
1270 pts[0].y = yDst;
1271 pts[1].x = xDst + widthDst;
1272 pts[1].y = yDst + heightDst;
1273 LPtoDP(physDevDst->hdc, pts, 2);
1274 xDst = pts[0].x;
1275 yDst = pts[0].y;
1276 widthDst = pts[1].x - pts[0].x;
1277 heightDst = pts[1].y - pts[0].y;
1278
1279 TRACE(" rectdst=%d,%d-%d,%d orgdst=%d,%d\n",
1280 xDst, yDst, widthDst, heightDst,
1281 physDevDst->dc_rect.left, physDevDst->dc_rect.top );
1282
1283 if (useSrc)
1284 {
1285 pts[0].x = xSrc;
1286 pts[0].y = ySrc;
1287 pts[1].x = xSrc + widthSrc;
1288 pts[1].y = ySrc + heightSrc;
1289 LPtoDP(physDevSrc->hdc, pts, 2);
1290 xSrc = pts[0].x;
1291 ySrc = pts[0].y;
1292 widthSrc = pts[1].x - pts[0].x;
1293 heightSrc = pts[1].y - pts[0].y;
1294
1295 fStretch = (widthSrc != widthDst) || (heightSrc != heightDst);
1296 TRACE(" rectsrc=%d,%d-%d,%d orgsrc=%d,%d\n",
1297 xSrc, ySrc, widthSrc, heightSrc,
1298 physDevSrc->dc_rect.left, physDevSrc->dc_rect.top );
1299 if (!BITBLT_GetVisRectangles( physDevDst, xDst, yDst, widthDst, heightDst,
1300 physDevSrc, xSrc, ySrc, widthSrc, heightSrc,
1301 &visRectSrc, &visRectDst ))
1302 return TRUE;
1303 TRACE(" vissrc=%d,%d-%d,%d visdst=%d,%d-%d,%d\n",
1304 visRectSrc.left, visRectSrc.top,
1305 visRectSrc.right, visRectSrc.bottom,
1306 visRectDst.left, visRectDst.top,
1307 visRectDst.right, visRectDst.bottom );
1308 }
1309 else
1310 {
1311 fStretch = FALSE;
1312 if (!BITBLT_GetVisRectangles( physDevDst, xDst, yDst, widthDst, heightDst,
1313 NULL, 0, 0, 0, 0, NULL, &visRectDst ))
1314 return TRUE;
1315 TRACE(" vissrc=none visdst=%d,%d-%d,%d\n",
1316 visRectDst.left, visRectDst.top,
1317 visRectDst.right, visRectDst.bottom );
1318 }
1319
1320 width = visRectDst.right - visRectDst.left;
1321 height = visRectDst.bottom - visRectDst.top;
1322
1323 opcode = BITBLT_Opcodes[(rop >> 16) & 0xff];
1324
1325 /* a few optimizations for single-op ROPs */
1326 if (!fStretch && !opcode[1])
1327 {
1328 if (OP_SRCDST(*opcode) == OP_ARGS(PAT,DST))
1329 {
1330 switch(rop) /* a few special cases */
1331 {
1332 case BLACKNESS: /* 0x00 */
1333 case WHITENESS: /* 0xff */
1334 if ((physDevDst->depth != 1) && X11DRV_PALETTE_PaletteToXPixel)
1335 {
1336 wine_tsx11_lock();
1337 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1338 if (rop == BLACKNESS)
1339 XSetForeground( gdi_display, physDevDst->gc, X11DRV_PALETTE_PaletteToXPixel[0] );
1340 else
1341 XSetForeground( gdi_display, physDevDst->gc,
1342 WhitePixel( gdi_display, DefaultScreen(gdi_display) ));
1343 XSetFillStyle( gdi_display, physDevDst->gc, FillSolid );
1344 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1345 physDevDst->dc_rect.left + visRectDst.left,
1346 physDevDst->dc_rect.top + visRectDst.top,
1347 width, height );
1348 wine_tsx11_unlock();
1349 return TRUE;
1350 }
1351 break;
1352 case DSTINVERT: /* 0x55 */
1353 if (!(X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_PRIVATE | X11DRV_PALETTE_VIRTUAL)))
1354 {
1355 /* Xor is much better when we do not have full colormap. */
1356 /* Using white^black ensures that we invert at least black */
1357 /* and white. */
1358 unsigned long xor_pix = (WhitePixel( gdi_display, DefaultScreen(gdi_display) ) ^
1359 BlackPixel( gdi_display, DefaultScreen(gdi_display) ));
1360 wine_tsx11_lock();
1361 XSetFunction( gdi_display, physDevDst->gc, GXxor );
1362 XSetForeground( gdi_display, physDevDst->gc, xor_pix);
1363 XSetFillStyle( gdi_display, physDevDst->gc, FillSolid );
1364 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1365 physDevDst->dc_rect.left + visRectDst.left,
1366 physDevDst->dc_rect.top + visRectDst.top,
1367 width, height );
1368 wine_tsx11_unlock();
1369 return TRUE;
1370 }
1371 break;
1372 }
1373 if (!usePat || X11DRV_SetupGCForBrush( physDevDst ))
1374 {
1375 wine_tsx11_lock();
1376 XSetFunction( gdi_display, physDevDst->gc, OP_ROP(*opcode) );
1377 XFillRectangle( gdi_display, physDevDst->drawable, physDevDst->gc,
1378 physDevDst->dc_rect.left + visRectDst.left,
1379 physDevDst->dc_rect.top + visRectDst.top,
1380 width, height );
1381 wine_tsx11_unlock();
1382 }
1383 return TRUE;
1384 }
1385 else if (OP_SRCDST(*opcode) == OP_ARGS(SRC,DST))
1386 {
1387 if (physDevSrc->depth == physDevDst->depth)
1388 {
1389 wine_tsx11_lock();
1390 XSetFunction( gdi_display, physDevDst->gc, OP_ROP(*opcode) );
1391 XCopyArea( gdi_display, physDevSrc->drawable,
1392 physDevDst->drawable, physDevDst->gc,
1393 physDevSrc->dc_rect.left + visRectSrc.left,
1394 physDevSrc->dc_rect.top + visRectSrc.top,
1395 width, height,
1396 physDevDst->dc_rect.left + visRectDst.left,
1397 physDevDst->dc_rect.top + visRectDst.top );
1398 physDevDst->exposures++;
1399 wine_tsx11_unlock();
1400 return TRUE;
1401 }
1402 if (physDevSrc->depth == 1)
1403 {
1404 int fg, bg;
1405 get_colors(physDevDst, physDevSrc, &fg, &bg);
1406 wine_tsx11_lock();
1407
1408 XSetBackground( gdi_display, physDevDst->gc, fg );
1409 XSetForeground( gdi_display, physDevDst->gc, bg );
1410 XSetFunction( gdi_display, physDevDst->gc, OP_ROP(*opcode) );
1411 XCopyPlane( gdi_display, physDevSrc->drawable,
1412 physDevDst->drawable, physDevDst->gc,
1413 physDevSrc->dc_rect.left + visRectSrc.left,
1414 physDevSrc->dc_rect.top + visRectSrc.top,
1415 width, height,
1416 physDevDst->dc_rect.left + visRectDst.left,
1417 physDevDst->dc_rect.top + visRectDst.top, 1 );
1418 physDevDst->exposures++;
1419 wine_tsx11_unlock();
1420 return TRUE;
1421 }
1422 }
1423 }
1424
1425 wine_tsx11_lock();
1426 tmpGC = XCreateGC( gdi_display, physDevDst->drawable, 0, NULL );
1427 XSetSubwindowMode( gdi_display, tmpGC, IncludeInferiors );
1428 XSetGraphicsExposures( gdi_display, tmpGC, False );
1429 pixmaps[DST] = XCreatePixmap( gdi_display, root_window, width, height,
1430 physDevDst->depth );
1431 wine_tsx11_unlock();
1432
1433 if (useSrc)
1434 {
1435 wine_tsx11_lock();
1436 pixmaps[SRC] = XCreatePixmap( gdi_display, root_window, width, height,
1437 physDevDst->depth );
1438 wine_tsx11_unlock();
1439 if (fStretch)
1440 BITBLT_GetSrcAreaStretch( physDevSrc, physDevDst, pixmaps[SRC], tmpGC,
1441 xSrc, ySrc, widthSrc, heightSrc,
1442 xDst, yDst, widthDst, heightDst,
1443 &visRectSrc, &visRectDst );
1444 else
1445 BITBLT_GetSrcArea( physDevSrc, physDevDst, pixmaps[SRC], tmpGC,
1446 &visRectSrc );
1447 }
1448
1449 if (useDst) BITBLT_GetDstArea( physDevDst, pixmaps[DST], tmpGC, &visRectDst );
1450 if (usePat) fNullBrush = !X11DRV_SetupGCForPatBlt( physDevDst, tmpGC, TRUE );
1451 else fNullBrush = FALSE;
1452 destUsed = FALSE;
1453
1454 wine_tsx11_lock();
1455 for ( ; *opcode; opcode++)
1456 {
1457 if (OP_DST(*opcode) == DST) destUsed = TRUE;
1458 XSetFunction( gdi_display, tmpGC, OP_ROP(*opcode) );
1459 switch(OP_SRCDST(*opcode))
1460 {
1461 case OP_ARGS(DST,TMP):
1462 case OP_ARGS(SRC,TMP):
1463 if (!pixmaps[TMP])
1464 pixmaps[TMP] = XCreatePixmap( gdi_display, root_window,
1465 width, height, physDevDst->depth );
1466 /* fall through */
1467 case OP_ARGS(DST,SRC):
1468 case OP_ARGS(SRC,DST):
1469 case OP_ARGS(TMP,SRC):
1470 case OP_ARGS(TMP,DST):
1471 if (useSrc)
1472 XCopyArea( gdi_display, pixmaps[OP_SRC(*opcode)],
1473 pixmaps[OP_DST(*opcode)], tmpGC,
1474 0, 0, width, height, 0, 0 );
1475 break;
1476
1477 case OP_ARGS(PAT,TMP):
1478 if (!pixmaps[TMP] && !fNullBrush)
1479 pixmaps[TMP] = XCreatePixmap( gdi_display, root_window,
1480 width, height, physDevDst->depth );
1481 /* fall through */
1482 case OP_ARGS(PAT,DST):
1483 case OP_ARGS(PAT,SRC):
1484 if (!fNullBrush)
1485 XFillRectangle( gdi_display, pixmaps[OP_DST(*opcode)],
1486 tmpGC, 0, 0, width, height );
1487 break;
1488 }
1489 }
1490 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1491 physDevDst->exposures += BITBLT_PutDstArea( physDevDst, pixmaps[destUsed ? DST : SRC],
1492 &visRectDst );
1493 XFreePixmap( gdi_display, pixmaps[DST] );
1494 if (pixmaps[SRC]) XFreePixmap( gdi_display, pixmaps[SRC] );
1495 if (pixmaps[TMP]) XFreePixmap( gdi_display, pixmaps[TMP] );
1496 XFreeGC( gdi_display, tmpGC );
1497 wine_tsx11_unlock();
1498 return TRUE;
1499 }
1500
1501
1502 /***********************************************************************
1503 * X11DRV_PatBlt
1504 */
1505 BOOL X11DRV_PatBlt( X11DRV_PDEVICE *physDev, INT left, INT top, INT width, INT height, DWORD rop )
1506 {
1507 BOOL result;
1508
1509 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1510 result = BITBLT_InternalStretchBlt( physDev, left, top, width, height, NULL, 0, 0, 0, 0, rop );
1511 X11DRV_UnlockDIBSection( physDev, TRUE );
1512 return result;
1513 }
1514
1515
1516 /***********************************************************************
1517 * X11DRV_ClientSideDIBCopy
1518 */
1519 static BOOL X11DRV_ClientSideDIBCopy( X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1520 X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1521 INT width, INT height )
1522 {
1523 DIBSECTION srcDib, dstDib;
1524 BYTE *srcPtr, *dstPtr;
1525 INT srcRowOffset, dstRowOffset;
1526 INT bytesPerPixel;
1527 INT bytesToCopy;
1528 INT y;
1529 static RECT unusedRect;
1530
1531 if (GetObjectW(physDevSrc->bitmap->hbitmap, sizeof(srcDib), &srcDib) != sizeof(srcDib))
1532 return FALSE;
1533 if (GetObjectW(physDevDst->bitmap->hbitmap, sizeof(dstDib), &dstDib) != sizeof(dstDib))
1534 return FALSE;
1535
1536 /* check for oversized values, just like X11DRV_DIB_CopyDIBSection() */
1537 if (xSrc > srcDib.dsBm.bmWidth || ySrc > srcDib.dsBm.bmHeight)
1538 return FALSE;
1539 if (xSrc + width > srcDib.dsBm.bmWidth)
1540 width = srcDib.dsBm.bmWidth - xSrc;
1541 if (ySrc + height > srcDib.dsBm.bmHeight)
1542 height = srcDib.dsBm.bmHeight - ySrc;
1543
1544 if (GetRgnBox(physDevSrc->region, &unusedRect) == COMPLEXREGION ||
1545 GetRgnBox(physDevDst->region, &unusedRect) == COMPLEXREGION)
1546 {
1547 /* for simple regions, the clipping was already done by BITBLT_GetVisRectangles */
1548 FIXME("potential optimization: client-side complex region clipping\n");
1549 return FALSE;
1550 }
1551 if (dstDib.dsBm.bmBitsPixel <= 8)
1552 {
1553 FIXME("potential optimization: client-side color-index mode DIB copy\n");
1554 return FALSE;
1555 }
1556 if (!(srcDib.dsBmih.biCompression == BI_BITFIELDS &&
1557 dstDib.dsBmih.biCompression == BI_BITFIELDS &&
1558 !memcmp(srcDib.dsBitfields, dstDib.dsBitfields, 3*sizeof(DWORD)))
1559 && !(srcDib.dsBmih.biCompression == BI_RGB &&
1560 dstDib.dsBmih.biCompression == BI_RGB))
1561 {
1562 FIXME("potential optimization: client-side compressed DIB copy\n");
1563 return FALSE;
1564 }
1565 if (srcDib.dsBm.bmBitsPixel != dstDib.dsBm.bmBitsPixel)
1566 {
1567 FIXME("potential optimization: pixel format conversion\n");
1568 return FALSE;
1569 }
1570 if (srcDib.dsBmih.biWidth < 0 || dstDib.dsBmih.biWidth < 0)
1571 {
1572 FIXME("negative widths not yet implemented\n");
1573 return FALSE;
1574 }
1575
1576 switch (dstDib.dsBm.bmBitsPixel)
1577 {
1578 case 15:
1579 case 16:
1580 bytesPerPixel = 2;
1581 break;
1582 case 24:
1583 bytesPerPixel = 3;
1584 break;
1585 case 32:
1586 bytesPerPixel = 4;
1587 break;
1588 default:
1589 FIXME("don't know how to work with a depth of %d\n", physDevSrc->depth);
1590 return FALSE;
1591 }
1592
1593 bytesToCopy = width * bytesPerPixel;
1594
1595 if (srcDib.dsBmih.biHeight < 0)
1596 {
1597 srcPtr = &physDevSrc->bitmap->base[ySrc*srcDib.dsBm.bmWidthBytes + xSrc*bytesPerPixel];
1598 srcRowOffset = srcDib.dsBm.bmWidthBytes;
1599 }
1600 else
1601 {
1602 srcPtr = &physDevSrc->bitmap->base[(srcDib.dsBm.bmHeight-ySrc-1)*srcDib.dsBm.bmWidthBytes
1603 + xSrc*bytesPerPixel];
1604 srcRowOffset = -srcDib.dsBm.bmWidthBytes;
1605 }
1606 if (dstDib.dsBmih.biHeight < 0)
1607 {
1608 dstPtr = &physDevDst->bitmap->base[yDst*dstDib.dsBm.bmWidthBytes + xDst*bytesPerPixel];
1609 dstRowOffset = dstDib.dsBm.bmWidthBytes;
1610 }
1611 else
1612 {
1613 dstPtr = &physDevDst->bitmap->base[(dstDib.dsBm.bmHeight-yDst-1)*dstDib.dsBm.bmWidthBytes
1614 + xDst*bytesPerPixel];
1615 dstRowOffset = -dstDib.dsBm.bmWidthBytes;
1616 }
1617
1618 /* Handle overlapping regions on the same DIB */
1619 if (physDevSrc == physDevDst && ySrc < yDst)
1620 {
1621 srcPtr += srcRowOffset * (height - 1);
1622 srcRowOffset = -srcRowOffset;
1623 dstPtr += dstRowOffset * (height - 1);
1624 dstRowOffset = -dstRowOffset;
1625 }
1626
1627 for (y = yDst; y < yDst + height; ++y)
1628 {
1629 memmove(dstPtr, srcPtr, bytesToCopy);
1630 srcPtr += srcRowOffset;
1631 dstPtr += dstRowOffset;
1632 }
1633
1634 return TRUE;
1635 }
1636
1637
1638 /***********************************************************************
1639 * X11DRV_BitBlt
1640 */
1641 BOOL X11DRV_BitBlt( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1642 INT width, INT height, X11DRV_PDEVICE *physDevSrc,
1643 INT xSrc, INT ySrc, DWORD rop )
1644 {
1645 BOOL result = FALSE;
1646 INT sSrc, sDst;
1647 RECT visRectDst, visRectSrc;
1648
1649 if (((rop >> 16) & 0x55) == ((rop >> 17) & 0x55)) {
1650 /* FIXME: seems the ROP doesn't include destination;
1651 * now if the destination area include the entire dcDst,
1652 * we can pass TRUE instead of FALSE to CoerceDIBSection(dcDst...),
1653 * which may avoid a copy in some situations */
1654 }
1655
1656 sDst = X11DRV_LockDIBSection( physDevDst, DIB_Status_None );
1657 if (physDevDst != physDevSrc)
1658 sSrc = X11DRV_LockDIBSection( physDevSrc, DIB_Status_None );
1659 else
1660 sSrc = sDst;
1661
1662 if ((sSrc == DIB_Status_AppMod) && (rop == SRCCOPY) &&
1663 (physDevSrc->depth == physDevDst->depth))
1664 {
1665 POINT pts[2];
1666 /* do everything ourselves; map coordinates */
1667
1668 pts[0].x = xSrc;
1669 pts[0].y = ySrc;
1670 pts[1].x = xSrc + width;
1671 pts[1].y = ySrc + height;
1672
1673 LPtoDP(physDevSrc->hdc, pts, 2);
1674 width = pts[1].x - pts[0].x;
1675 height = pts[1].y - pts[0].y;
1676 xSrc = pts[0].x;
1677 ySrc = pts[0].y;
1678
1679 pts[0].x = xDst;
1680 pts[0].y = yDst;
1681 LPtoDP(physDevDst->hdc, pts, 1);
1682
1683 xDst = pts[0].x;
1684 yDst = pts[0].y;
1685
1686 /* Perform basic clipping */
1687 if (!BITBLT_GetVisRectangles( physDevDst, xDst, yDst, width, height,
1688 physDevSrc, xSrc, ySrc, width, height,
1689 &visRectSrc, &visRectDst ))
1690 goto END;
1691
1692 xSrc = visRectSrc.left;
1693 ySrc = visRectSrc.top;
1694 xDst = visRectDst.left;
1695 yDst = visRectDst.top;
1696 width = visRectDst.right - visRectDst.left;
1697 height = visRectDst.bottom - visRectDst.top;
1698
1699 if (sDst == DIB_Status_AppMod) {
1700 result = X11DRV_ClientSideDIBCopy( physDevSrc, xSrc, ySrc,
1701 physDevDst, xDst, yDst,
1702 width, height );
1703 if (result)
1704 goto END;
1705 /* fall back to X server copying */
1706 }
1707 X11DRV_CoerceDIBSection( physDevDst, DIB_Status_GdiMod );
1708
1709 wine_tsx11_lock();
1710 XSetFunction( gdi_display, physDevDst->gc, GXcopy );
1711 wine_tsx11_unlock();
1712
1713 X11DRV_DIB_CopyDIBSection( physDevSrc, physDevDst, xSrc, ySrc, xDst, yDst, width, height );
1714 result = TRUE;
1715 goto END;
1716 }
1717
1718 X11DRV_CoerceDIBSection( physDevDst, DIB_Status_GdiMod );
1719 if (physDevDst != physDevSrc)
1720 X11DRV_CoerceDIBSection( physDevSrc, DIB_Status_GdiMod );
1721
1722 result = BITBLT_InternalStretchBlt( physDevDst, xDst, yDst, width, height,
1723 physDevSrc, xSrc, ySrc, width, height, rop );
1724
1725 END:
1726 if (physDevDst != physDevSrc)
1727 X11DRV_UnlockDIBSection( physDevSrc, FALSE );
1728 X11DRV_UnlockDIBSection( physDevDst, TRUE );
1729
1730 return result;
1731 }
1732
1733
1734 /***********************************************************************
1735 * X11DRV_StretchBlt
1736 */
1737 BOOL X11DRV_StretchBlt( X11DRV_PDEVICE *physDevDst, INT xDst, INT yDst,
1738 INT widthDst, INT heightDst,
1739 X11DRV_PDEVICE *physDevSrc, INT xSrc, INT ySrc,
1740 INT widthSrc, INT heightSrc, DWORD rop )
1741 {
1742 BOOL result;
1743
1744 X11DRV_LockDIBSection( physDevDst, DIB_Status_GdiMod );
1745 if (physDevDst != physDevSrc)
1746 X11DRV_LockDIBSection( physDevSrc, DIB_Status_GdiMod );
1747
1748 result = BITBLT_InternalStretchBlt( physDevDst, xDst, yDst, widthDst, heightDst,
1749 physDevSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
1750
1751 if (physDevDst != physDevSrc)
1752 X11DRV_UnlockDIBSection( physDevSrc, FALSE );
1753 X11DRV_UnlockDIBSection( physDevDst, TRUE );
1754 return result;
1755 }
Maarten's multimedia branch