1 /*
2 * Copyright (c) 2004, 2015, 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
28 #include "sun_java2d_opengl_WGLSurfaceData.h"
29
30 #include "jni.h"
31 #include "jlong.h"
32 #include "jni_util.h"
33 #include "sizecalc.h"
34 #include "OGLRenderQueue.h"
35 #include "WGLGraphicsConfig.h"
36 #include "WGLSurfaceData.h"
37
38 /**
39 * The methods in this file implement the native windowing system specific
40 * layer (WGL) for the OpenGL-based Java 2D pipeline.
41 */
42
43 extern LockFunc OGLSD_Lock;
44 extern GetRasInfoFunc OGLSD_GetRasInfo;
45 extern UnlockFunc OGLSD_Unlock;
46 extern DisposeFunc OGLSD_Dispose;
47
48 extern OGLPixelFormat PixelFormats[];
49 extern void AwtWindow_UpdateWindow(JNIEnv *env, jobject peer,
50 jint w, jint h, HBITMAP hBitmap);
51 extern HBITMAP BitmapUtil_CreateBitmapFromARGBPre(int width, int height,
52 int srcStride,
53 int* imageData);
54 extern void AwtComponent_GetInsets(JNIEnv *env, jobject peer, RECT *insets);
55
56 extern void
57 OGLSD_SetNativeDimensions(JNIEnv *env, OGLSDOps *oglsdo, jint w, jint h);
58
59 JNIEXPORT void JNICALL
60 Java_sun_java2d_opengl_WGLSurfaceData_initOps(JNIEnv *env, jobject wglsd,
61 jlong pConfigInfo,
62 jobject peer, jlong hwnd)
63 {
64 OGLSDOps *oglsdo = (OGLSDOps *)SurfaceData_InitOps(env, wglsd,
65 sizeof(OGLSDOps));
66 WGLSDOps *wglsdo = (WGLSDOps *)malloc(sizeof(WGLSDOps));
67
68 J2dTraceLn(J2D_TRACE_INFO, "WGLSurfaceData_initOps");
69
70 if (wglsdo == NULL) {
71 JNU_ThrowOutOfMemoryError(env, "creating native wgl ops");
72 return;
73 }
74 if (oglsdo == NULL) {
75 free(wglsdo);
76 JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
77 return;
78 }
79
80 oglsdo->privOps = wglsdo;
81
82 oglsdo->sdOps.Lock = OGLSD_Lock;
83 oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
84 oglsdo->sdOps.Unlock = OGLSD_Unlock;
85 oglsdo->sdOps.Dispose = OGLSD_Dispose;
86
87 oglsdo->drawableType = OGLSD_UNDEFINED;
88 oglsdo->activeBuffer = GL_FRONT;
89 oglsdo->needsInit = JNI_TRUE;
90 if (peer != NULL) {
91 RECT insets;
92 AwtComponent_GetInsets(env, peer, &insets);
93 oglsdo->xOffset = -insets.left;
94 oglsdo->yOffset = -insets.bottom;
95 } else {
96 oglsdo->xOffset = 0;
97 oglsdo->yOffset = 0;
98 }
99
100 wglsdo->window = (HWND)jlong_to_ptr(hwnd);
101 wglsdo->configInfo = (WGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
102 if (wglsdo->configInfo == NULL) {
103 free(wglsdo);
104 JNU_ThrowNullPointerException(env, "Config info is null in initOps");
105 }
106 }
107
108 /**
109 * This function disposes of any native windowing system resources associated
110 * with this surface.
111 */
112 void
113 OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
114 {
115 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
116 // Window is free'd later by AWT code...
117 }
118
119 /**
120 * Makes the given context current to its associated "scratch" surface. If
121 * the operation is successful, this method will return JNI_TRUE; otherwise,
122 * returns JNI_FALSE.
123 */
124 static jboolean
125 WGLSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc)
126 {
127 WGLCtxInfo *ctxInfo;
128
129 J2dTraceLn(J2D_TRACE_INFO, "WGLSD_MakeCurrentToScratch");
130
131 if (oglc == NULL) {
132 J2dRlsTraceLn(J2D_TRACE_ERROR,
133 "WGLSD_MakeCurrentToScratch: context is null");
134 return JNI_FALSE;
135 }
136
137 ctxInfo = (WGLCtxInfo *)oglc->ctxInfo;
138 if (!j2d_wglMakeCurrent(ctxInfo->scratchSurfaceDC, ctxInfo->context)) {
139 J2dRlsTraceLn(J2D_TRACE_ERROR,
140 "WGLSD_MakeCurrentToScratch: could not make current");
141 return JNI_FALSE;
142 }
143
144 return JNI_TRUE;
145 }
146
147 /**
148 * Returns a pointer (as a jlong) to the native WGLGraphicsConfigInfo
149 * associated with the given OGLSDOps. This method can be called from
150 * shared code to retrieve the native GraphicsConfig data in a platform-
151 * independent manner.
152 */
153 jlong
154 OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
155 {
156 WGLSDOps *wglsdo;
157
158 if (oglsdo == NULL) {
159 J2dRlsTraceLn(J2D_TRACE_ERROR,
160 "OGLSD_GetNativeConfigInfo: ops are null");
161 return 0L;
162 }
163
164 wglsdo = (WGLSDOps *)oglsdo->privOps;
165 if (wglsdo == NULL) {
166 J2dRlsTraceLn(J2D_TRACE_ERROR,
167 "OGLSD_GetNativeConfigInfo: wgl ops are null");
168 return 0L;
169 }
170
171 return ptr_to_jlong(wglsdo->configInfo);
172 }
173
174 /**
175 * Makes the given GraphicsConfig's context current to its associated
176 * "scratch" surface. If there is a problem making the context current,
177 * this method will return NULL; otherwise, returns a pointer to the
178 * OGLContext that is associated with the given GraphicsConfig.
179 */
180 OGLContext *
181 OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
182 {
183 WGLGraphicsConfigInfo *wglInfo =
184 (WGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
185 OGLContext *oglc;
186
187 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
188
189 if (wglInfo == NULL) {
190 J2dRlsTraceLn(J2D_TRACE_ERROR,
191 "OGLSD_SetScratchContext: wgl config info is null");
192 return NULL;
193 }
194
195 oglc = wglInfo->context;
196 if (!WGLSD_MakeCurrentToScratch(env, oglc)) {
197 return NULL;
198 }
199
200 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
201 // the GL_EXT_framebuffer_object extension is present, so this call
202 // will ensure that we are bound to the scratch pbuffer (and not
203 // some other framebuffer object)
204 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
205 }
206
207 return oglc;
208 }
209
210 /**
211 * Makes a context current to the given source and destination
212 * surfaces. If there is a problem making the context current, this method
213 * will return NULL; otherwise, returns a pointer to the OGLContext that is
214 * associated with the destination surface.
215 */
216 OGLContext *
217 OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
218 {
219 WGLSDOps *srcWGLOps = (WGLSDOps *)srcOps->privOps;
220 WGLSDOps *dstWGLOps = (WGLSDOps *)dstOps->privOps;
221 OGLContext *oglc;
222 WGLCtxInfo *ctxinfo;
223 HDC srcHDC, dstHDC;
224 BOOL success;
225
226 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
227
228 J2dTraceLn4(J2D_TRACE_VERBOSE, " src: %d %p dst: %d %p",
229 srcOps->drawableType, srcOps,
230 dstOps->drawableType, dstOps);
231
232 oglc = dstWGLOps->configInfo->context;
233 if (oglc == NULL) {
234 J2dRlsTraceLn(J2D_TRACE_ERROR,
235 "OGLSD_MakeOGLContextCurrent: context is null");
236 return NULL;
237 }
238
239 if (dstOps->drawableType == OGLSD_FBOBJECT) {
240 OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
241
242 // first make sure we have a current context (if the context isn't
243 // already current to some drawable, we will make it current to
244 // its scratch surface)
245 if (oglc != currentContext) {
246 if (!WGLSD_MakeCurrentToScratch(env, oglc)) {
247 return NULL;
248 }
249 }
250
251 // now bind to the fbobject associated with the destination surface;
252 // this means that all rendering will go into the fbobject destination
253 // (note that we unbind the currently bound texture first; this is
254 // recommended procedure when binding an fbobject)
255 j2d_glBindTexture(dstOps->textureTarget, 0);
256 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
257
258 return oglc;
259 }
260
261 ctxinfo = (WGLCtxInfo *)oglc->ctxInfo;
262
263 // get the hdc for the destination surface
264 dstHDC = GetDC(dstWGLOps->window);
265
266 // get the hdc for the source surface
267 // the source will always be equal to the destination in this case
268 srcHDC = dstHDC;
269
270 // REMIND: in theory we should be able to use wglMakeContextCurrentARB()
271 // even when the src/dst surfaces are the same, but this causes problems
272 // on ATI's drivers (see 6525997); for now we will only use it when the
273 // surfaces are different, otherwise we will use the old
274 // wglMakeCurrent() approach...
275 if (srcHDC != dstHDC) {
276 // use WGL_ARB_make_current_read extension to make context current
277 success =
278 j2d_wglMakeContextCurrentARB(dstHDC, srcHDC, ctxinfo->context);
279 } else {
280 // use the old approach for making current to the destination
281 success = j2d_wglMakeCurrent(dstHDC, ctxinfo->context);
282 }
283 if (!success) {
284 J2dRlsTraceLn(J2D_TRACE_ERROR,
285 "OGLSD_MakeOGLContextCurrent: could not make current");
286 ReleaseDC(dstWGLOps->window, dstHDC);
287 return NULL;
288 }
289
290 if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
291 // the GL_EXT_framebuffer_object extension is present, so we
292 // must bind to the default (windowing system provided)
293 // framebuffer
294 j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
295 }
296
297 ReleaseDC(dstWGLOps->window, dstHDC);
298
299 return oglc;
300 }
301
302 /**
303 * This function initializes a native window surface and caches the window
304 * bounds in the given OGLSDOps. Returns JNI_TRUE if the operation was
305 * successful; JNI_FALSE otherwise.
306 */
307 jboolean
308 OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
309 {
310 PIXELFORMATDESCRIPTOR pfd;
311 WGLSDOps *wglsdo;
312 WGLGraphicsConfigInfo *wglInfo;
313 HWND window;
314 RECT wbounds;
315 HDC hdc;
316
317 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
318
319 if (oglsdo == NULL) {
320 J2dRlsTraceLn(J2D_TRACE_ERROR,
321 "OGLSD_InitOGLWindow: ops are null");
322 return JNI_FALSE;
323 }
324
325 wglsdo = (WGLSDOps *)oglsdo->privOps;
326 if (wglsdo == NULL) {
327 J2dRlsTraceLn(J2D_TRACE_ERROR,
328 "OGLSD_InitOGLWindow: wgl ops are null");
329 return JNI_FALSE;
330 }
331
332 wglInfo = wglsdo->configInfo;
333 if (wglInfo == NULL) {
334 J2dRlsTraceLn(J2D_TRACE_ERROR,
335 "OGLSD_InitOGLWindow: graphics config info is null");
336 return JNI_FALSE;
337 }
338
339 window = wglsdo->window;
340 if (!IsWindow(window)) {
341 J2dRlsTraceLn(J2D_TRACE_ERROR,
342 "OGLSD_InitOGLWindow: disposed component");
343 return JNI_FALSE;
344 }
345
346 GetWindowRect(window, &wbounds);
347
348 hdc = GetDC(window);
349 if (hdc == 0) {
350 J2dRlsTraceLn(J2D_TRACE_ERROR,
351 "OGLSD_InitOGLWindow: invalid hdc");
352 return JNI_FALSE;
353 }
354
355 if (!SetPixelFormat(hdc, wglInfo->pixfmt, &pfd)) {
356 J2dRlsTraceLn(J2D_TRACE_ERROR,
357 "OGLSD_InitOGLWindow: error setting pixel format");
358 ReleaseDC(window, hdc);
359 return JNI_FALSE;
360 }
361
362 ReleaseDC(window, hdc);
363
364 oglsdo->drawableType = OGLSD_WINDOW;
365 oglsdo->isOpaque = JNI_TRUE;
366 oglsdo->width = wbounds.right - wbounds.left;
367 oglsdo->height = wbounds.bottom - wbounds.top;
368 wglsdo->pbufferDC = 0;
369
370 J2dTraceLn2(J2D_TRACE_VERBOSE, " created window: w=%d h=%d",
371 oglsdo->width, oglsdo->height);
372
373 return JNI_TRUE;
374 }
375
376 void
377 OGLSD_SwapBuffers(JNIEnv *env, jlong pPeerData)
378 {
379 HWND window;
380 HDC hdc;
381
382 J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
383
384 window = AwtComponent_GetHWnd(env, pPeerData);
385 if (!IsWindow(window)) {
386 J2dRlsTraceLn(J2D_TRACE_ERROR,
387 "OGLSD_SwapBuffers: disposed component");
388 return;
389 }
390
391 hdc = GetDC(window);
392 if (hdc == 0) {
393 J2dRlsTraceLn(J2D_TRACE_ERROR,
394 "OGLSD_SwapBuffers: invalid hdc");
395 return;
396 }
397
398 if (!SwapBuffers(hdc)) {
399 J2dRlsTraceLn(J2D_TRACE_ERROR,
400 "OGLSD_SwapBuffers: error in SwapBuffers");
401 }
402
403 if (!ReleaseDC(window, hdc)) {
404 J2dRlsTraceLn(J2D_TRACE_ERROR,
405 "OGLSD_SwapBuffers: error while releasing dc");
406 }
407 }
408
409 // needed by Mac OS X port, no-op on other platforms
410 void
411 OGLSD_Flush(JNIEnv *env)
412 {
413 }
414
415 /*
416 * Class: sun_java2d_opengl_WGLSurfaceData
417 * Method: updateWindowAccelImpl
418 * Signature: (JJII)Z
419 */
420 JNIEXPORT jboolean JNICALL
421 Java_sun_java2d_opengl_WGLSurfaceData_updateWindowAccelImpl
422 (JNIEnv *env, jclass clazz, jlong pData, jobject peer, jint w, jint h)
423 {
424 OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
425 OGLPixelFormat pf = PixelFormats[0/*PF_INT_ARGB_PRE*/];
426 HBITMAP hBitmap = NULL;
427 void *pDst;
428 jint srcx, srcy, dstx, dsty, width, height;
429 jint pixelStride = 4;
430 jint scanStride = pixelStride * w;
431
432 J2dTraceLn(J2D_TRACE_INFO, "WGLSurfaceData_updateWindowAccelImpl");
433
434 if (w <= 0 || h <= 0) {
435 return JNI_TRUE;
436 }
437 if (oglsdo == NULL) {
438 return JNI_FALSE;
439 }
440 RESET_PREVIOUS_OP();
441
442 width = w;
443 height = h;
444 srcx = srcy = dstx = dsty = 0;
445
446 pDst = SAFE_SIZE_ARRAY_ALLOC(malloc, height, scanStride);
447 if (pDst == NULL) {
448 return JNI_FALSE;
449 }
450 ZeroMemory(pDst, height * scanStride);
451
452 // the code below is mostly copied from OGLBlitLoops_SurfaceToSwBlit
453
454 j2d_glPixelStorei(GL_PACK_SKIP_PIXELS, dstx);
455 j2d_glPixelStorei(GL_PACK_ROW_LENGTH, scanStride / pixelStride);
456 j2d_glPixelStorei(GL_PACK_ALIGNMENT, pf.alignment);
457
458 // this accounts for lower-left origin of the source region
459 srcx = oglsdo->xOffset + srcx;
460 srcy = oglsdo->yOffset + oglsdo->height - (srcy + 1);
461 // we must read one scanline at a time because there is no way
462 // to read starting at the top-left corner of the source region
463 while (height > 0) {
464 j2d_glPixelStorei(GL_PACK_SKIP_ROWS, dsty);
465 j2d_glReadPixels(srcx, srcy, width, 1,
466 pf.format, pf.type, pDst);
467 srcy--;
468 dsty++;
469 height--;
470 }
471
472 j2d_glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
473 j2d_glPixelStorei(GL_PACK_SKIP_ROWS, 0);
474 j2d_glPixelStorei(GL_PACK_ROW_LENGTH, 0);
475 j2d_glPixelStorei(GL_PACK_ALIGNMENT, 4);
476
477 // the pixels read from the surface are already premultiplied
478 hBitmap = BitmapUtil_CreateBitmapFromARGBPre(w, h, scanStride,
479 (int*)pDst);
480 free(pDst);
481
482 if (hBitmap == NULL) {
483 return JNI_FALSE;
484 }
485
486 AwtWindow_UpdateWindow(env, peer, w, h, hBitmap);
487
488 // hBitmap is released in UpdateWindow
489
490 return JNI_TRUE;
491 }