1 /*
2 * Copyright (c) 2000, 2007, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include <stdlib.h>
27 #include <jni.h>
28 #include <jlong.h>
29 #include "X11SurfaceData.h"
30 #include "Region.h"
31
32 JNIEXPORT void JNICALL
33 Java_sun_java2d_x11_X11PMBlitLoops_nativeBlit
34 (JNIEnv *env, jobject joSelf,
35 jlong srcData, jlong dstData,
36 jlong gc, jobject clip,
37 jint srcx, jint srcy,
38 jint dstx, jint dsty,
39 jint width, jint height)
40 {
41 #ifndef HEADLESS
42 X11SDOps *srcXsdo, *dstXsdo;
43 SurfaceDataBounds span, srcBounds;
44 RegionData clipInfo;
45 GC xgc;
46
47 if (width <= 0 || height <= 0) {
48 return;
49 }
50
51 srcXsdo = (X11SDOps *)jlong_to_ptr(srcData);
52 if (srcXsdo == NULL) {
53 return;
54 }
55 dstXsdo = (X11SDOps *)jlong_to_ptr(dstData);
56 if (dstXsdo == NULL) {
57 return;
58 }
59 if (Region_GetInfo(env, clip, &clipInfo)) {
60 return;
61 }
62
63 xgc = (GC)gc;
64 if (xgc == NULL) {
65 return;
66 }
67
68 #ifdef MITSHM
69 if (srcXsdo->isPixmap) {
70 X11SD_UnPuntPixmap(srcXsdo);
71 }
72 #endif /* MITSHM */
73
74 /* clip the source rect to the source pixmap's dimensions */
75 srcBounds.x1 = srcx;
76 srcBounds.y1 = srcy;
77 srcBounds.x2 = srcx + width;
78 srcBounds.y2 = srcy + height;
79 SurfaceData_IntersectBoundsXYXY(&srcBounds,
80 0, 0, srcXsdo->pmWidth, srcXsdo->pmHeight);
81 span.x1 = dstx;
82 span.y1 = dsty;
83 span.x2 = dstx + width;
84 span.y2 = dsty + height;
85
86 /* intersect the source and dest rects */
87 SurfaceData_IntersectBlitBounds(&srcBounds, &span,
88 dstx - srcx, dsty - srcy);
89 srcx = srcBounds.x1;
90 srcy = srcBounds.y1;
91 dstx = span.x1;
92 dsty = span.y1;
93
94 if (srcXsdo->bitmask != 0) {
95 XSetClipOrigin(awt_display, xgc, dstx - srcx, dsty - srcy);
96 XSetClipMask(awt_display, xgc, srcXsdo->bitmask);
97 }
98
99 Region_IntersectBounds(&clipInfo, &span);
100 if (!Region_IsEmpty(&clipInfo)) {
101 Region_StartIteration(env, &clipInfo);
102 srcx -= dstx;
103 srcy -= dsty;
104 while (Region_NextIteration(&clipInfo, &span)) {
105 XCopyArea(awt_display, srcXsdo->drawable, dstXsdo->drawable, xgc,
106 srcx + span.x1, srcy + span.y1,
107 span.x2 - span.x1, span.y2 - span.y1,
108 span.x1, span.y1);
109 }
110 Region_EndIteration(env, &clipInfo);
111 }
112
113 if (srcXsdo->bitmask != 0) {
114 XSetClipMask(awt_display, xgc, None);
115 }
116
117 #ifdef MITSHM
118 if (srcXsdo->shmPMData.usingShmPixmap) {
119 srcXsdo->shmPMData.xRequestSent = JNI_TRUE;
120 }
121 #endif /* MITSHM */
122 X11SD_DirectRenderNotify(env, dstXsdo);
123 #endif /* !HEADLESS */
124 }
125
126 JNIEXPORT void JNICALL
127 Java_sun_java2d_x11_X11PMBlitBgLoops_nativeBlitBg
128 (JNIEnv *env, jobject joSelf,
129 jlong srcData, jlong dstData,
130 jlong xgc, jint pixel,
131 jint srcx, jint srcy,
132 jint dstx, jint dsty,
133 jint width, jint height)
134 {
135 #ifndef HEADLESS
136 X11SDOps *srcXsdo, *dstXsdo;
137 GC dstGC;
138 SurfaceDataBounds dstBounds, srcBounds;
139 Drawable srcDrawable;
140
141 if (width <= 0 || height <= 0) {
142 return;
143 }
144
145 srcXsdo = (X11SDOps *)jlong_to_ptr(srcData);
146 if (srcXsdo == NULL) {
147 return;
148 }
149 dstXsdo = (X11SDOps *)jlong_to_ptr(dstData);
150 if (dstXsdo == NULL) {
151 return;
152 }
153
154 dstGC = (GC)xgc;
155 if (dstGC == NULL) {
156 return;
157 }
158
159 #ifdef MITSHM
160 if (srcXsdo->isPixmap) {
161 X11SD_UnPuntPixmap(srcXsdo);
162 }
163 #endif /* MITSHM */
164
165 srcDrawable = srcXsdo->GetPixmapWithBg(env, srcXsdo, pixel);
166 if (srcDrawable == 0) {
167 return;
168 }
169
170 /* clip the source rect to the source pixmap's dimensions */
171 srcBounds.x1 = srcx;
172 srcBounds.y1 = srcy;
173 srcBounds.x2 = srcx + width;
174 srcBounds.y2 = srcy + height;
175 SurfaceData_IntersectBoundsXYXY(&srcBounds,
176 0, 0, srcXsdo->pmWidth, srcXsdo->pmHeight);
177 dstBounds.x1 = dstx;
178 dstBounds.y1 = dsty;
179 dstBounds.x2 = dstx + width;
180 dstBounds.y2 = dsty + height;
181
182 /* intersect the source and dest rects */
183 SurfaceData_IntersectBlitBounds(&srcBounds, &dstBounds,
184 dstx - srcx, dsty - srcy);
185 srcx = srcBounds.x1;
186 srcy = srcBounds.y1;
187 dstx = dstBounds.x1;
188 dsty = dstBounds.y1;
189 width = srcBounds.x2 - srcBounds.x1;
190 height = srcBounds.y2 - srcBounds.y1;
191
192 /* do an unmasked copy as we've already filled transparent
193 pixels of the source image with the desired color */
194 XCopyArea(awt_display, srcDrawable, dstXsdo->drawable, dstGC,
195 srcx, srcy, width, height, dstx, dsty);
196
197 srcXsdo->ReleasePixmapWithBg(env, srcXsdo);
198 X11SD_DirectRenderNotify(env, dstXsdo);
199 #endif /* !HEADLESS */
200 }
201
202 /*
203 * Class: sun_java2d_x11_X11PMBlitLoops
204 * Method: updateBitmask
205 * Signature: (Lsun/java2d/SurfaceData;Lsun/java2d/SurfaceData;)V
206 */
207 JNIEXPORT void JNICALL
208 Java_sun_java2d_x11_X11PMBlitLoops_updateBitmask
209 (JNIEnv *env, jclass xpmbl, jobject srcsd, jobject dstsd, jboolean isICM)
210 {
211 #ifndef HEADLESS
212 SurfaceDataOps *srcOps = SurfaceData_GetOps(env, srcsd);
213 X11SDOps *xsdo = (X11SDOps *) SurfaceData_GetOps(env, dstsd);
214 SurfaceDataRasInfo srcInfo;
215
216 int flags;
217 int screen;
218 int width;
219 int height;
220 jint srcScan, dstScan;
221 int rowCount;
222 unsigned char *pDst;
223 XImage *image;
224 GC xgc;
225
226 if (srcOps == NULL || xsdo == NULL) {
227 JNU_ThrowNullPointerException(env, "Null BISD in updateMaskRegion");
228 return;
229 }
230
231 AWT_LOCK();
232
233 screen = xsdo->configData->awt_visInfo.screen;
234 width = xsdo->pmWidth;
235 height = xsdo->pmHeight;
236
237 if (xsdo->bitmask == 0) {
238 /* create the bitmask if it is not yet created */
239 xsdo->bitmask = XCreatePixmap(awt_display,
240 RootWindow(awt_display, screen),
241 width, height, 1);
242 if (xsdo->bitmask == 0) {
243 AWT_UNLOCK();
244 if (!(*env)->ExceptionCheck(env))
245 {
246 JNU_ThrowOutOfMemoryError(env,
247 "Cannot create bitmask for "
248 "offscreen surface");
249 }
250 return;
251 }
252 }
253
254 /* Create a bitmask image and then blit it to the pixmap. */
255 image = XCreateImage(awt_display, DefaultVisual(awt_display, screen),
256 1, XYBitmap, 0, NULL, width, height, 32, 0);
257 if (image == NULL) {
258 AWT_UNLOCK();
259 if (!(*env)->ExceptionCheck(env))
260 {
261 JNU_ThrowOutOfMemoryError(env, "Cannot allocate bitmask for mask");
262 }
263 return;
264 }
265 dstScan = image->bytes_per_line;
266 image->data = malloc(dstScan * height);
267 if (image->data == NULL) {
268 XFree(image);
269 AWT_UNLOCK();
270 if (!(*env)->ExceptionCheck(env))
271 {
272 JNU_ThrowOutOfMemoryError(env, "Cannot allocate bitmask for mask");
273 }
274 return;
275 }
276 pDst = (unsigned char *)image->data;
277
278 srcInfo.bounds.x1 = 0;
279 srcInfo.bounds.y1 = 0;
280 srcInfo.bounds.x2 = width;
281 srcInfo.bounds.y2 = height;
282
283 flags = (isICM ? (SD_LOCK_LUT | SD_LOCK_READ) : SD_LOCK_READ);
284 if (srcOps->Lock(env, srcOps, &srcInfo, flags) != SD_SUCCESS) {
285 XDestroyImage(image);
286 AWT_UNLOCK();
287 return;
288 }
289 srcOps->GetRasInfo(env, srcOps, &srcInfo);
290
291 rowCount = height;
292 if (isICM) {
293 unsigned char *pSrc;
294 jint *srcLut;
295
296 srcScan = srcInfo.scanStride;
297 srcLut = srcInfo.lutBase;
298 pSrc = (unsigned char *)srcInfo.rasBase;
299
300 if (image->bitmap_bit_order == MSBFirst) {
301 do {
302 int x = 0, bx = 0;
303 unsigned int pix = 0;
304 unsigned int bit = 0x80;
305 unsigned char *srcPixel = pSrc;
306 do {
307 if (bit == 0) {
308 pDst[bx++] = (unsigned char)pix;
309 pix = 0;
310 bit = 0x80;
311 }
312 pix |= bit & (srcLut[*srcPixel++] >> 31);
313 bit >>= 1;
314 } while (++x < width);
315 pDst[bx] = (unsigned char)pix;
316 pDst += dstScan;
317 pSrc = (unsigned char *) (((intptr_t)pSrc) + srcScan);
318 } while (--rowCount > 0);
319 } else {
320 do {
321 int x = 0, bx = 0;
322 unsigned int pix = 0;
323 unsigned int bit = 1;
324 unsigned char *srcPixel = pSrc;
325 do {
326 if ((bit >> 8) != 0) {
327 pDst[bx++] = (unsigned char) pix;
328 pix = 0;
329 bit = 1;
330 }
331 pix |= bit & (srcLut[*srcPixel++] >> 31);
332 bit <<= 1;
333 } while (++x < width);
334 pDst[bx] = (unsigned char) pix;
335 pDst += dstScan;
336 pSrc = (unsigned char *) (((intptr_t)pSrc) + srcScan);
337 } while (--rowCount > 0);
338 }
339 } else /*DCM with ARGB*/ {
340 unsigned int *pSrc;
341
342 /* this is a number of pixels in a row, not number of bytes */
343 srcScan = srcInfo.scanStride;
344 pSrc = (unsigned int *)srcInfo.rasBase;
345
346 if (image->bitmap_bit_order == MSBFirst) {
347 do {
348 int x = 0, bx = 0;
349 unsigned int pix = 0;
350 unsigned int bit = 0x80;
351 int *srcPixel = (int *) pSrc;
352 do {
353 if (bit == 0) {
354 /* next word */
355 pDst[bx++] = (unsigned char)pix;
356 pix = 0;
357 bit = 0x80;
358 }
359 if (*srcPixel++ & 0xff000000) {
360 /* if src pixel is opaque, set the bit in the bitmap */
361 pix |= bit;
362 }
363 bit >>= 1;
364 } while (++x < width);
365 /* last pixels in a row */
366 pDst[bx] = (unsigned char)pix;
367
368 pDst += dstScan;
369 pSrc = (unsigned int *) (((intptr_t)pSrc) + srcScan);
370 } while (--rowCount > 0);
371 } else {
372 do {
373 int x = 0, bx = 0;
374 unsigned int pix = 0;
375 unsigned int bit = 1;
376 int *srcPixel = (int *) pSrc;
377 do {
378 if ((bit >> 8) != 0) {
379 pDst[bx++] = (unsigned char)pix;
380 pix = 0;
381 bit = 1;
382 }
383 if (*srcPixel++ & 0xff000000) {
384 /* if src pixel is opaque, set the bit in the bitmap */
385 pix |= bit;
386 }
387 bit <<= 1;
388 } while (++x < width);
389 pDst[bx] = (unsigned char)pix;
390 pDst += dstScan;
391 pSrc = (unsigned int *) (((intptr_t)pSrc) + srcScan);
392 } while (--rowCount > 0);
393 }
394 }
395 SurfaceData_InvokeRelease(env, srcOps, &srcInfo);
396 SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
397
398 xgc = XCreateGC(awt_display, xsdo->bitmask, 0L, NULL);
399 XSetForeground(awt_display, xgc, 1);
400 XSetBackground(awt_display, xgc, 0);
401 XPutImage(awt_display, xsdo->bitmask, xgc,
402 image, 0, 0, 0, 0, width, height);
403
404 XFreeGC(awt_display, xgc);
405 XDestroyImage(image);
406
407 AWT_UNLOCK();
408 #endif /* !HEADLESS */
409 }