1 /*
   2  * Copyright (c) 2004, 2013, 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.  For instance, if the given OGLSDOps is of type
 111  * OGLSD_PBUFFER, this method implementation will destroy the actual pbuffer
 112  * surface.
 113  */
 114 void
 115 OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
 116 {
 117     WGLSDOps *wglsdo = (WGLSDOps *)oglsdo->privOps;
 118 
 119     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
 120 
 121     if (oglsdo->drawableType == OGLSD_PBUFFER) {
 122         if (wglsdo->pbuffer != 0) {
 123             if (wglsdo->pbufferDC != 0) {
 124                 j2d_wglReleasePbufferDCARB(wglsdo->pbuffer,
 125                                            wglsdo->pbufferDC);
 126                 wglsdo->pbufferDC = 0;
 127             }
 128             j2d_wglDestroyPbufferARB(wglsdo->pbuffer);
 129             wglsdo->pbuffer = 0;
 130         }
 131     }
 132 }
 133 
 134 /**
 135  * Makes the given context current to its associated "scratch" surface.  If
 136  * the operation is successful, this method will return JNI_TRUE; otherwise,
 137  * returns JNI_FALSE.
 138  */
 139 static jboolean
 140 WGLSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc)
 141 {
 142     WGLCtxInfo *ctxInfo;
 143 
 144     J2dTraceLn(J2D_TRACE_INFO, "WGLSD_MakeCurrentToScratch");
 145 
 146     if (oglc == NULL) {
 147         J2dRlsTraceLn(J2D_TRACE_ERROR,
 148                       "WGLSD_MakeCurrentToScratch: context is null");
 149         return JNI_FALSE;
 150     }
 151 
 152     ctxInfo = (WGLCtxInfo *)oglc->ctxInfo;
 153     if (!j2d_wglMakeCurrent(ctxInfo->scratchSurfaceDC, ctxInfo->context)) {
 154         J2dRlsTraceLn(J2D_TRACE_ERROR,
 155                       "WGLSD_MakeCurrentToScratch: could not make current");
 156         return JNI_FALSE;
 157     }
 158 
 159     return JNI_TRUE;
 160 }
 161 
 162 /**
 163  * Returns a pointer (as a jlong) to the native WGLGraphicsConfigInfo
 164  * associated with the given OGLSDOps.  This method can be called from
 165  * shared code to retrieve the native GraphicsConfig data in a platform-
 166  * independent manner.
 167  */
 168 jlong
 169 OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
 170 {
 171     WGLSDOps *wglsdo;
 172 
 173     if (oglsdo == NULL) {
 174         J2dRlsTraceLn(J2D_TRACE_ERROR,
 175                       "OGLSD_GetNativeConfigInfo: ops are null");
 176         return 0L;
 177     }
 178 
 179     wglsdo = (WGLSDOps *)oglsdo->privOps;
 180     if (wglsdo == NULL) {
 181         J2dRlsTraceLn(J2D_TRACE_ERROR,
 182                       "OGLSD_GetNativeConfigInfo: wgl ops are null");
 183         return 0L;
 184     }
 185 
 186     return ptr_to_jlong(wglsdo->configInfo);
 187 }
 188 
 189 /**
 190  * Makes the given GraphicsConfig's context current to its associated
 191  * "scratch" surface.  If there is a problem making the context current,
 192  * this method will return NULL; otherwise, returns a pointer to the
 193  * OGLContext that is associated with the given GraphicsConfig.
 194  */
 195 OGLContext *
 196 OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
 197 {
 198     WGLGraphicsConfigInfo *wglInfo =
 199         (WGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
 200     OGLContext *oglc;
 201 
 202     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
 203 
 204     if (wglInfo == NULL) {
 205         J2dRlsTraceLn(J2D_TRACE_ERROR,
 206                       "OGLSD_SetScratchContext: wgl config info is null");
 207         return NULL;
 208     }
 209 
 210     oglc = wglInfo->context;
 211     if (!WGLSD_MakeCurrentToScratch(env, oglc)) {
 212         return NULL;
 213     }
 214 
 215     if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
 216         // the GL_EXT_framebuffer_object extension is present, so this call
 217         // will ensure that we are bound to the scratch pbuffer (and not
 218         // some other framebuffer object)
 219         j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 220     }
 221 
 222     return oglc;
 223 }
 224 
 225 /**
 226  * Makes a context current to the given source and destination
 227  * surfaces.  If there is a problem making the context current, this method
 228  * will return NULL; otherwise, returns a pointer to the OGLContext that is
 229  * associated with the destination surface.
 230  */
 231 OGLContext *
 232 OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
 233 {
 234     WGLSDOps *srcWGLOps = (WGLSDOps *)srcOps->privOps;
 235     WGLSDOps *dstWGLOps = (WGLSDOps *)dstOps->privOps;
 236     OGLContext *oglc;
 237     WGLCtxInfo *ctxinfo;
 238     HDC srcHDC, dstHDC;
 239     BOOL success;
 240 
 241     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
 242 
 243     J2dTraceLn4(J2D_TRACE_VERBOSE, "  src: %d %p dst: %d %p",
 244                 srcOps->drawableType, srcOps,
 245                 dstOps->drawableType, dstOps);
 246 
 247     oglc = dstWGLOps->configInfo->context;
 248     if (oglc == NULL) {
 249         J2dRlsTraceLn(J2D_TRACE_ERROR,
 250                       "OGLSD_MakeOGLContextCurrent: context is null");
 251         return NULL;
 252     }
 253 
 254     if (dstOps->drawableType == OGLSD_FBOBJECT) {
 255         OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
 256 
 257         // first make sure we have a current context (if the context isn't
 258         // already current to some drawable, we will make it current to
 259         // its scratch surface)
 260         if (oglc != currentContext) {
 261             if (!WGLSD_MakeCurrentToScratch(env, oglc)) {
 262                 return NULL;
 263             }
 264         }
 265 
 266         // now bind to the fbobject associated with the destination surface;
 267         // this means that all rendering will go into the fbobject destination
 268         // (note that we unbind the currently bound texture first; this is
 269         // recommended procedure when binding an fbobject)
 270         j2d_glBindTexture(dstOps->textureTarget, 0);
 271         j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
 272 
 273         return oglc;
 274     }
 275 
 276     ctxinfo = (WGLCtxInfo *)oglc->ctxInfo;
 277 
 278     // get the hdc for the destination surface
 279     if (dstOps->drawableType == OGLSD_PBUFFER) {
 280         dstHDC = dstWGLOps->pbufferDC;
 281     } else {
 282         dstHDC = GetDC(dstWGLOps->window);
 283     }
 284 
 285     // get the hdc for the source surface
 286     if (srcOps->drawableType == OGLSD_PBUFFER) {
 287         srcHDC = srcWGLOps->pbufferDC;
 288     } else {
 289         // the source will always be equal to the destination in this case
 290         srcHDC = dstHDC;
 291     }
 292 
 293     // REMIND: in theory we should be able to use wglMakeContextCurrentARB()
 294     // even when the src/dst surfaces are the same, but this causes problems
 295     // on ATI's drivers (see 6525997); for now we will only use it when the
 296     // surfaces are different, otherwise we will use the old
 297     // wglMakeCurrent() approach...
 298     if (srcHDC != dstHDC) {
 299         // use WGL_ARB_make_current_read extension to make context current
 300         success =
 301             j2d_wglMakeContextCurrentARB(dstHDC, srcHDC, ctxinfo->context);
 302     } else {
 303         // use the old approach for making current to the destination
 304         success = j2d_wglMakeCurrent(dstHDC, ctxinfo->context);
 305     }
 306     if (!success) {
 307         J2dRlsTraceLn(J2D_TRACE_ERROR,
 308                       "OGLSD_MakeOGLContextCurrent: could not make current");
 309         if (dstOps->drawableType != OGLSD_PBUFFER) {
 310             ReleaseDC(dstWGLOps->window, dstHDC);
 311         }
 312         return NULL;
 313     }
 314 
 315     if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
 316         // the GL_EXT_framebuffer_object extension is present, so we
 317         // must bind to the default (windowing system provided)
 318         // framebuffer
 319         j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 320     }
 321 
 322     if (dstOps->drawableType != OGLSD_PBUFFER) {
 323         ReleaseDC(dstWGLOps->window, dstHDC);
 324     }
 325 
 326     return oglc;
 327 }
 328 
 329 /**
 330  * This function initializes a native window surface and caches the window
 331  * bounds in the given OGLSDOps.  Returns JNI_TRUE if the operation was
 332  * successful; JNI_FALSE otherwise.
 333  */
 334 jboolean
 335 OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
 336 {
 337     PIXELFORMATDESCRIPTOR pfd;
 338     WGLSDOps *wglsdo;
 339     WGLGraphicsConfigInfo *wglInfo;
 340     HWND window;
 341     RECT wbounds;
 342     HDC hdc;
 343 
 344     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
 345 
 346     if (oglsdo == NULL) {
 347         J2dRlsTraceLn(J2D_TRACE_ERROR,
 348                       "OGLSD_InitOGLWindow: ops are null");
 349         return JNI_FALSE;
 350     }
 351 
 352     wglsdo = (WGLSDOps *)oglsdo->privOps;
 353     if (wglsdo == NULL) {
 354         J2dRlsTraceLn(J2D_TRACE_ERROR,
 355                       "OGLSD_InitOGLWindow: wgl ops are null");
 356         return JNI_FALSE;
 357     }
 358 
 359     wglInfo = wglsdo->configInfo;
 360     if (wglInfo == NULL) {
 361         J2dRlsTraceLn(J2D_TRACE_ERROR,
 362                       "OGLSD_InitOGLWindow: graphics config info is null");
 363         return JNI_FALSE;
 364     }
 365 
 366     window = wglsdo->window;
 367     if (!IsWindow(window)) {
 368         J2dRlsTraceLn(J2D_TRACE_ERROR,
 369                       "OGLSD_InitOGLWindow: disposed component");
 370         return JNI_FALSE;
 371     }
 372 
 373     GetWindowRect(window, &wbounds);
 374 
 375     hdc = GetDC(window);
 376     if (hdc == 0) {
 377         J2dRlsTraceLn(J2D_TRACE_ERROR,
 378                       "OGLSD_InitOGLWindow: invalid hdc");
 379         return JNI_FALSE;
 380     }
 381 
 382     if (!SetPixelFormat(hdc, wglInfo->pixfmt, &pfd)) {
 383         J2dRlsTraceLn(J2D_TRACE_ERROR,
 384                       "OGLSD_InitOGLWindow: error setting pixel format");
 385         ReleaseDC(window, hdc);
 386         return JNI_FALSE;
 387     }
 388 
 389     ReleaseDC(window, hdc);
 390 
 391     oglsdo->drawableType = OGLSD_WINDOW;
 392     oglsdo->isOpaque = JNI_TRUE;
 393     oglsdo->width = wbounds.right - wbounds.left;
 394     oglsdo->height = wbounds.bottom - wbounds.top;
 395     wglsdo->pbufferDC = 0;
 396 
 397     J2dTraceLn2(J2D_TRACE_VERBOSE, "  created window: w=%d h=%d",
 398                 oglsdo->width, oglsdo->height);
 399 
 400     return JNI_TRUE;
 401 }
 402 
 403 JNIEXPORT jboolean JNICALL
 404 Java_sun_java2d_opengl_WGLSurfaceData_initPbuffer
 405     (JNIEnv *env, jobject wglsd,
 406      jlong pData, jlong pConfigInfo,
 407      jboolean isOpaque,
 408      jint width, jint height)
 409 {
 410     int attrKeys[] = {
 411         WGL_MAX_PBUFFER_WIDTH_ARB,
 412         WGL_MAX_PBUFFER_HEIGHT_ARB,
 413     };
 414     int attrVals[2];
 415     int pbAttrList[] = { 0 };
 416     OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
 417     WGLGraphicsConfigInfo *wglInfo =
 418         (WGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
 419     WGLSDOps *wglsdo;
 420     HWND hwnd;
 421     HDC hdc, pbufferDC;
 422     HPBUFFERARB pbuffer;
 423     int maxWidth, maxHeight;
 424     int actualWidth, actualHeight;
 425 
 426     J2dTraceLn3(J2D_TRACE_INFO,
 427                 "WGLSurfaceData_initPbuffer: w=%d h=%d opq=%d",
 428                 width, height, isOpaque);
 429 
 430     if (oglsdo == NULL) {
 431         J2dRlsTraceLn(J2D_TRACE_ERROR,
 432             "WGLSurfaceData_initPbuffer: ops are null");
 433         return JNI_FALSE;
 434     }
 435 
 436     wglsdo = (WGLSDOps *)oglsdo->privOps;
 437     if (wglsdo == NULL) {
 438         J2dRlsTraceLn(J2D_TRACE_ERROR,
 439             "WGLSurfaceData_initPbuffer: wgl ops are null");
 440         return JNI_FALSE;
 441     }
 442 
 443     if (wglInfo == NULL) {
 444         J2dRlsTraceLn(J2D_TRACE_ERROR,
 445             "WGLSurfaceData_initPbuffer: wgl config info is null");
 446         return JNI_FALSE;
 447     }
 448 
 449     // create a scratch window
 450     hwnd = WGLGC_CreateScratchWindow(wglInfo->screen);
 451     if (hwnd == 0) {
 452         J2dRlsTraceLn(J2D_TRACE_ERROR,
 453             "WGLSurfaceData_initPbuffer: could not create scratch window");
 454         return JNI_FALSE;
 455     }
 456 
 457     // get the HDC for the scratch window
 458     hdc = GetDC(hwnd);
 459     if (hdc == 0) {
 460         J2dRlsTraceLn(J2D_TRACE_ERROR,
 461             "WGLSurfaceData_initPbuffer: could not get dc for scratch window");
 462         DestroyWindow(hwnd);
 463         return JNI_FALSE;
 464     }
 465 
 466     // get the maximum allowable pbuffer dimensions
 467     j2d_wglGetPixelFormatAttribivARB(hdc, wglInfo->pixfmt, 0, 2,
 468                                      attrKeys, attrVals);
 469     maxWidth  = attrVals[0];
 470     maxHeight = attrVals[1];
 471 
 472     J2dTraceLn4(J2D_TRACE_VERBOSE,
 473                 "  desired pbuffer dimensions: w=%d h=%d maxw=%d maxh=%d",
 474                 width, height, maxWidth, maxHeight);
 475 
 476     // if either dimension is 0 or larger than the maximum, we cannot
 477     // allocate a pbuffer with the requested dimensions
 478     if (width  == 0 || width  > maxWidth ||
 479         height == 0 || height > maxHeight)
 480     {
 481         J2dRlsTraceLn(J2D_TRACE_ERROR,
 482             "WGLSurfaceData_initPbuffer: invalid dimensions");
 483         ReleaseDC(hwnd, hdc);
 484         DestroyWindow(hwnd);
 485         return JNI_FALSE;
 486     }
 487 
 488     pbuffer = j2d_wglCreatePbufferARB(hdc, wglInfo->pixfmt,
 489                                       width, height, pbAttrList);
 490 
 491     ReleaseDC(hwnd, hdc);
 492     DestroyWindow(hwnd);
 493 
 494     if (pbuffer == 0) {
 495         J2dRlsTraceLn(J2D_TRACE_ERROR,
 496             "WGLSurfaceData_initPbuffer: could not create wgl pbuffer");
 497         return JNI_FALSE;
 498     }
 499 
 500     // note that we get the DC for the pbuffer at creation time, and then
 501     // release the DC when the pbuffer is disposed; the WGL_ARB_pbuffer
 502     // spec is vague about such things, but from past experience we know
 503     // this approach to be more robust than, for example, doing a
 504     // Get/ReleasePbufferDC() everytime we make a context current
 505     pbufferDC = j2d_wglGetPbufferDCARB(pbuffer);
 506     if (pbufferDC == 0) {
 507         J2dRlsTraceLn(J2D_TRACE_ERROR,
 508             "WGLSurfaceData_initPbuffer: could not get dc for pbuffer");
 509         j2d_wglDestroyPbufferARB(pbuffer);
 510         return JNI_FALSE;
 511     }
 512 
 513     // make sure the actual dimensions match those that we requested
 514     j2d_wglQueryPbufferARB(pbuffer, WGL_PBUFFER_WIDTH_ARB, &actualWidth);
 515     j2d_wglQueryPbufferARB(pbuffer, WGL_PBUFFER_HEIGHT_ARB, &actualHeight);
 516 
 517     if (width != actualWidth || height != actualHeight) {
 518         J2dRlsTraceLn2(J2D_TRACE_ERROR,
 519             "WGLSurfaceData_initPbuffer: actual (w=%d h=%d) != requested",
 520                        actualWidth, actualHeight);
 521         j2d_wglReleasePbufferDCARB(pbuffer, pbufferDC);
 522         j2d_wglDestroyPbufferARB(pbuffer);
 523         return JNI_FALSE;
 524     }
 525 
 526     oglsdo->drawableType = OGLSD_PBUFFER;
 527     oglsdo->isOpaque = isOpaque;
 528     oglsdo->width = width;
 529     oglsdo->height = height;
 530     wglsdo->pbuffer = pbuffer;
 531     wglsdo->pbufferDC = pbufferDC;
 532 
 533     OGLSD_SetNativeDimensions(env, oglsdo, width, height);
 534 
 535     return JNI_TRUE;
 536 }
 537 
 538 void
 539 OGLSD_SwapBuffers(JNIEnv *env, jlong pPeerData)
 540 {
 541     HWND window;
 542     HDC hdc;
 543 
 544     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
 545 
 546     window = AwtComponent_GetHWnd(env, pPeerData);
 547     if (!IsWindow(window)) {
 548         J2dRlsTraceLn(J2D_TRACE_ERROR,
 549                       "OGLSD_SwapBuffers: disposed component");
 550         return;
 551     }
 552 
 553     hdc = GetDC(window);
 554     if (hdc == 0) {
 555         J2dRlsTraceLn(J2D_TRACE_ERROR,
 556                       "OGLSD_SwapBuffers: invalid hdc");
 557         return;
 558     }
 559 
 560     if (!SwapBuffers(hdc)) {
 561         J2dRlsTraceLn(J2D_TRACE_ERROR,
 562                       "OGLSD_SwapBuffers: error in SwapBuffers");
 563     }
 564 
 565     if (!ReleaseDC(window, hdc)) {
 566         J2dRlsTraceLn(J2D_TRACE_ERROR,
 567                       "OGLSD_SwapBuffers: error while releasing dc");
 568     }
 569 }
 570 
 571 // needed by Mac OS X port, no-op on other platforms
 572 void
 573 OGLSD_Flush(JNIEnv *env)
 574 {
 575 }
 576 
 577 /*
 578  * Class:     sun_java2d_opengl_WGLSurfaceData
 579  * Method:    updateWindowAccelImpl
 580  * Signature: (JJII)Z
 581  */
 582 JNIEXPORT jboolean JNICALL
 583     Java_sun_java2d_opengl_WGLSurfaceData_updateWindowAccelImpl
 584   (JNIEnv *env, jclass clazz, jlong pData, jobject peer, jint w, jint h)
 585 {
 586     OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
 587     OGLPixelFormat pf = PixelFormats[0/*PF_INT_ARGB_PRE*/];
 588     HBITMAP hBitmap = NULL;
 589     void *pDst;
 590     jint srcx, srcy, dstx, dsty, width, height;
 591     jint pixelStride = 4;
 592     jint scanStride = pixelStride * w;
 593 
 594     J2dTraceLn(J2D_TRACE_INFO, "WGLSurfaceData_updateWindowAccelImpl");
 595 
 596     if (w <= 0 || h <= 0) {
 597         return JNI_TRUE;
 598     }
 599     if (oglsdo == NULL) {
 600         return JNI_FALSE;
 601     }
 602     RESET_PREVIOUS_OP();
 603 
 604     width = w;
 605     height = h;
 606     srcx = srcy = dstx = dsty = 0;
 607 
 608     pDst = SAFE_SIZE_ARRAY_ALLOC(malloc, height, scanStride);
 609     if (pDst == NULL) {
 610         return JNI_FALSE;
 611     }
 612     ZeroMemory(pDst, height * scanStride);
 613 
 614     // the code below is mostly copied from OGLBlitLoops_SurfaceToSwBlit
 615 
 616     j2d_glPixelStorei(GL_PACK_SKIP_PIXELS, dstx);
 617     j2d_glPixelStorei(GL_PACK_ROW_LENGTH, scanStride / pixelStride);
 618     j2d_glPixelStorei(GL_PACK_ALIGNMENT, pf.alignment);
 619 
 620     // this accounts for lower-left origin of the source region
 621     srcx = oglsdo->xOffset + srcx;
 622     srcy = oglsdo->yOffset + oglsdo->height - (srcy + 1);
 623     // we must read one scanline at a time because there is no way
 624     // to read starting at the top-left corner of the source region
 625     while (height > 0) {
 626         j2d_glPixelStorei(GL_PACK_SKIP_ROWS, dsty);
 627         j2d_glReadPixels(srcx, srcy, width, 1,
 628                          pf.format, pf.type, pDst);
 629         srcy--;
 630         dsty++;
 631         height--;
 632     }
 633 
 634     j2d_glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
 635     j2d_glPixelStorei(GL_PACK_SKIP_ROWS, 0);
 636     j2d_glPixelStorei(GL_PACK_ROW_LENGTH, 0);
 637     j2d_glPixelStorei(GL_PACK_ALIGNMENT, 4);
 638 
 639     // the pixels read from the surface are already premultiplied
 640     hBitmap = BitmapUtil_CreateBitmapFromARGBPre(w, h, scanStride,
 641                                                  (int*)pDst);
 642     free(pDst);
 643 
 644     if (hBitmap == NULL) {
 645         return JNI_FALSE;
 646     }
 647 
 648     AwtWindow_UpdateWindow(env, peer, w, h, hBitmap);
 649 
 650     // hBitmap is released in UpdateWindow
 651 
 652     return JNI_TRUE;
 653 }
--- EOF ---