History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/java2d/opengl/OGLSurfaceData.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/java2d/opengl/OGLSurfaceData.java+653−0
@@ -0,0 +1,653 @@
1/*
2 * Copyright (c) 2003, 2008, 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
26package sun.java2d.opengl;
27
28import java.awt.AlphaComposite;
29import java.awt.GraphicsEnvironment;
30import java.awt.Rectangle;
31import java.awt.Transparency;
32import java.awt.image.ColorModel;
33import java.awt.image.Raster;
34import sun.awt.SunHints;
35import sun.awt.image.PixelConverter;
36import sun.java2d.pipe.hw.AccelSurface;
37import sun.java2d.SunGraphics2D;
38import sun.java2d.SurfaceData;
39import sun.java2d.SurfaceDataProxy;
40import sun.java2d.loops.CompositeType;
41import sun.java2d.loops.GraphicsPrimitive;
42import sun.java2d.loops.MaskFill;
43import sun.java2d.loops.SurfaceType;
44import sun.java2d.pipe.ParallelogramPipe;
45import sun.java2d.pipe.PixelToParallelogramConverter;
46import sun.java2d.pipe.RenderBuffer;
47import sun.java2d.pipe.TextPipe;
48import static sun.java2d.pipe.BufferedOpCodes.*;
49import static sun.java2d.opengl.OGLContext.OGLContextCaps.*;
50
51/**
52 * This class describes an OpenGL "surface", that is, a region of pixels
53 * managed via OpenGL. An OGLSurfaceData can be tagged with one of three
54 * different SurfaceType objects for the purpose of registering loops, etc.
55 * This diagram shows the hierarchy of OGL SurfaceTypes:
56 *
57 * Any
58 * / \
59 * OpenGLSurface OpenGLTexture
60 * |
61 * OpenGLSurfaceRTT
62 *
63 * OpenGLSurface
64 * This kind of surface can be rendered to using OpenGL APIs. It is also
65 * possible to copy an OpenGLSurface to another OpenGLSurface (or to itself).
66 * This is typically accomplished by calling MakeContextCurrent(dstSD, srcSD)
67 * and then calling glCopyPixels() (although there are other techniques to
68 * achieve the same goal).
69 *
70 * OpenGLTexture
71 * This kind of surface cannot be rendered to using OpenGL (in the same sense
72 * as in OpenGLSurface). However, it is possible to upload a region of pixels
73 * to an OpenGLTexture object via glTexSubImage2D(). One can also copy a
74 * surface of type OpenGLTexture to an OpenGLSurface by binding the texture
75 * to a quad and then rendering it to the destination surface (this process
76 * is known as "texture mapping").
77 *
78 * OpenGLSurfaceRTT
79 * This kind of surface can be thought of as a sort of hybrid between
80 * OpenGLSurface and OpenGLTexture, in that one can render to this kind of
81 * surface as if it were of type OpenGLSurface, but the process of copying
82 * this kind of surface to another is more like an OpenGLTexture. (Note that
83 * "RTT" stands for "render-to-texture".)
84 *
85 * In addition to these SurfaceType variants, we have also defined some
86 * constants that describe in more detail the type of underlying OpenGL
87 * surface. This table helps explain the relationships between those
88 * "type" constants and their corresponding SurfaceType:
89 *
90 * OGL Type Corresponding SurfaceType
91 * -------- -------------------------
92 * WINDOW OpenGLSurface
93 * PBUFFER OpenGLSurface
94 * TEXTURE OpenGLTexture
95 * FLIP_BACKBUFFER OpenGLSurface
96 * FBOBJECT OpenGLSurfaceRTT
97 */
98public abstract class OGLSurfaceData extends SurfaceData
99 implements AccelSurface {
100
101 /**
102 * OGL-specific surface types
103 *
104 * @see sun.java2d.pipe.hw.AccelSurface
105 */
106 public static final int PBUFFER = RT_PLAIN;
107 public static final int FBOBJECT = RT_TEXTURE;
108
109 /**
110 * Pixel formats
111 */
112 public static final int PF_INT_ARGB = 0;
113 public static final int PF_INT_ARGB_PRE = 1;
114 public static final int PF_INT_RGB = 2;
115 public static final int PF_INT_RGBX = 3;
116 public static final int PF_INT_BGR = 4;
117 public static final int PF_INT_BGRX = 5;
118 public static final int PF_USHORT_565_RGB = 6;
119 public static final int PF_USHORT_555_RGB = 7;
120 public static final int PF_USHORT_555_RGBX = 8;
121 public static final int PF_BYTE_GRAY = 9;
122 public static final int PF_USHORT_GRAY = 10;
123 public static final int PF_3BYTE_BGR = 11;
124
125 /**
126 * SurfaceTypes
127 */
128 private static final String DESC_OPENGL_SURFACE = "OpenGL Surface";
129 private static final String DESC_OPENGL_SURFACE_RTT =
130 "OpenGL Surface (render-to-texture)";
131 private static final String DESC_OPENGL_TEXTURE = "OpenGL Texture";
132
133 static final SurfaceType OpenGLSurface =
134 SurfaceType.Any.deriveSubType(DESC_OPENGL_SURFACE,
135 PixelConverter.ArgbPre.instance);
136 static final SurfaceType OpenGLSurfaceRTT =
137 OpenGLSurface.deriveSubType(DESC_OPENGL_SURFACE_RTT);
138 static final SurfaceType OpenGLTexture =
139 SurfaceType.Any.deriveSubType(DESC_OPENGL_TEXTURE);
140
141 /** This will be true if the fbobject system property has been enabled. */
142 private static boolean isFBObjectEnabled;
143
144 /** This will be true if the lcdshader system property has been enabled.*/
145 private static boolean isLCDShaderEnabled;
146
147 /** This will be true if the biopshader system property has been enabled.*/
148 private static boolean isBIOpShaderEnabled;
149
150 /** This will be true if the gradshader system property has been enabled.*/
151 private static boolean isGradShaderEnabled;
152
153 private OGLGraphicsConfig graphicsConfig;
154 protected int type;
155 // these fields are set from the native code when the surface is
156 // initialized
157 private int nativeWidth, nativeHeight;
158
159 protected static OGLRenderer oglRenderPipe;
160 protected static PixelToParallelogramConverter oglTxRenderPipe;
161 protected static ParallelogramPipe oglAAPgramPipe;
162 protected static OGLTextRenderer oglTextPipe;
163 protected static OGLDrawImage oglImagePipe;
164
165 protected native boolean initTexture(long pData,
166 boolean isOpaque, boolean texNonPow2,
167 boolean texRect,
168 int width, int height);
169 protected native boolean initFBObject(long pData,
170 boolean isOpaque, boolean texNonPow2,
171 boolean texRect,
172 int width, int height);
173 protected native boolean initFlipBackbuffer(long pData);
174 protected abstract boolean initPbuffer(long pData, long pConfigInfo,
175 boolean isOpaque,
176 int width, int height);
177
178 private native int getTextureTarget(long pData);
179 private native int getTextureID(long pData);
180
181 static {
182 if (!GraphicsEnvironment.isHeadless()) {
183 // fbobject currently enabled by default; use "false" to disable
184 String fbo = (String)java.security.AccessController.doPrivileged(
185 new sun.security.action.GetPropertyAction(
186 "sun.java2d.opengl.fbobject"));
187 isFBObjectEnabled = !"false".equals(fbo);
188
189 // lcdshader currently enabled by default; use "false" to disable
190 String lcd = (String)java.security.AccessController.doPrivileged(
191 new sun.security.action.GetPropertyAction(
192 "sun.java2d.opengl.lcdshader"));
193 isLCDShaderEnabled = !"false".equals(lcd);
194
195 // biopshader currently enabled by default; use "false" to disable
196 String biop = (String)java.security.AccessController.doPrivileged(
197 new sun.security.action.GetPropertyAction(
198 "sun.java2d.opengl.biopshader"));
199 isBIOpShaderEnabled = !"false".equals(biop);
200
201 // gradshader currently enabled by default; use "false" to disable
202 String grad = (String)java.security.AccessController.doPrivileged(
203 new sun.security.action.GetPropertyAction(
204 "sun.java2d.opengl.gradshader"));
205 isGradShaderEnabled = !"false".equals(grad);
206
207 OGLRenderQueue rq = OGLRenderQueue.getInstance();
208 oglImagePipe = new OGLDrawImage();
209 oglTextPipe = new OGLTextRenderer(rq);
210 oglRenderPipe = new OGLRenderer(rq);
211 if (GraphicsPrimitive.tracingEnabled()) {
212 oglTextPipe = oglTextPipe.traceWrap();
213 //The wrapped oglRenderPipe will wrap the AA pipe as well...
214 //oglAAPgramPipe = oglRenderPipe.traceWrap();
215 }
216 oglAAPgramPipe = oglRenderPipe.getAAParallelogramPipe();
217 oglTxRenderPipe =
218 new PixelToParallelogramConverter(oglRenderPipe,
219 oglRenderPipe,
220 1.0, 0.25, true);
221
222 OGLBlitLoops.register();
223 OGLMaskFill.register();
224 OGLMaskBlit.register();
225 }
226 }
227
228 protected OGLSurfaceData(OGLGraphicsConfig gc,
229 ColorModel cm, int type)
230 {
231 super(getCustomSurfaceType(type), cm);
232 this.graphicsConfig = gc;
233 this.type = type;
234 setBlitProxyKey(gc.getProxyKey());
235 }
236
237 @Override
238 public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {
239 return OGLSurfaceDataProxy.createProxy(srcData, graphicsConfig);
240 }
241
242 /**
243 * Returns the appropriate SurfaceType corresponding to the given OpenGL
244 * surface type constant (e.g. TEXTURE -> OpenGLTexture).
245 */
246 private static SurfaceType getCustomSurfaceType(int oglType) {
247 switch (oglType) {
248 case TEXTURE:
249 return OpenGLTexture;
250 case FBOBJECT:
251 return OpenGLSurfaceRTT;
252 case PBUFFER:
253 default:
254 return OpenGLSurface;
255 }
256 }
257
258 /**
259 * Note: This should only be called from the QFT under the AWT lock.
260 * This method is kept separate from the initSurface() method below just
261 * to keep the code a bit cleaner.
262 */
263 private void initSurfaceNow(int width, int height) {
264 boolean isOpaque = (getTransparency() == Transparency.OPAQUE);
265 boolean success = false;
266
267 switch (type) {
268 case PBUFFER:
269 success = initPbuffer(getNativeOps(),
270 graphicsConfig.getNativeConfigInfo(),
271 isOpaque,
272 width, height);
273 break;
274
275 case TEXTURE:
276 success = initTexture(getNativeOps(),
277 isOpaque, isTexNonPow2Available(),
278 isTexRectAvailable(),
279 width, height);
280 break;
281
282 case FBOBJECT:
283 success = initFBObject(getNativeOps(),
284 isOpaque, isTexNonPow2Available(),
285 isTexRectAvailable(),
286 width, height);
287 break;
288
289 case FLIP_BACKBUFFER:
290 success = initFlipBackbuffer(getNativeOps());
291 break;
292
293 default:
294 break;
295 }
296
297 if (!success) {
298 throw new OutOfMemoryError("can't create offscreen surface");
299 }
300 }
301
302 /**
303 * Initializes the appropriate OpenGL offscreen surface based on the value
304 * of the type parameter. If the surface creation fails for any reason,
305 * an OutOfMemoryError will be thrown.
306 */
307 protected void initSurface(final int width, final int height) {
308 OGLRenderQueue rq = OGLRenderQueue.getInstance();
309 rq.lock();
310 try {
311 switch (type) {
312 case TEXTURE:
313 case PBUFFER:
314 case FBOBJECT:
315 // need to make sure the context is current before
316 // creating the texture (or pbuffer, or fbobject)
317 OGLContext.setScratchSurface(graphicsConfig);
318 break;
319 default:
320 break;
321 }
322 rq.flushAndInvokeNow(new Runnable() {
323 public void run() {
324 initSurfaceNow(width, height);
325 }
326 });
327 } finally {
328 rq.unlock();
329 }
330 }
331
332 /**
333 * Returns the OGLContext for the GraphicsConfig associated with this
334 * surface.
335 */
336 public final OGLContext getContext() {
337 return graphicsConfig.getContext();
338 }
339
340 /**
341 * Returns the OGLGraphicsConfig associated with this surface.
342 */
343 final OGLGraphicsConfig getOGLGraphicsConfig() {
344 return graphicsConfig;
345 }
346
347 /**
348 * Returns one of the surface type constants defined above.
349 */
350 public final int getType() {
351 return type;
352 }
353
354 /**
355 * If this surface is backed by a texture object, returns the target
356 * for that texture (either GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE_ARB).
357 * Otherwise, this method will return zero.
358 */
359 public final int getTextureTarget() {
360 return getTextureTarget(getNativeOps());
361 }
362
363 /**
364 * If this surface is backed by a texture object, returns the texture ID
365 * for that texture.
366 * Otherwise, this method will return zero.
367 */
368 public final int getTextureID() {
369 return getTextureID(getNativeOps());
370 }
371
372 /**
373 * Returns native resource of specified {@code resType} associated with
374 * this surface.
375 *
376 * Specifically, for {@code OGLSurfaceData} this method returns the
377 * the following:
378 * <pre>
379 * TEXTURE - texture id
380 * </pre>
381 *
382 * Note: the resource returned by this method is only valid on the rendering
383 * thread.
384 *
385 * @return native resource of specified type or 0L if
386 * such resource doesn't exist or can not be retrieved.
387 * @see sun.java2d.pipe.hw.AccelSurface#getNativeResource
388 */
389 public long getNativeResource(int resType) {
390 if (resType == TEXTURE) {
391 return getTextureID();
392 }
393 return 0L;
394 }
395
396 public Raster getRaster(int x, int y, int w, int h) {
397 throw new InternalError("not implemented yet");
398 }
399
400 /**
401 * For now, we can only render LCD text if:
402 * - the fragment shader extension is available, and
403 * - blending is disabled, and
404 * - the source color is opaque
405 * - and the destination is opaque
406 *
407 * Eventually, we could enhance the native OGL text rendering code
408 * and remove the above restrictions, but that would require significantly
409 * more code just to support a few uncommon cases.
410 */
411 public boolean canRenderLCDText(SunGraphics2D sg2d) {
412 return
413 graphicsConfig.isCapPresent(CAPS_EXT_LCD_SHADER) &&
414 sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY &&
415 sg2d.paintState <= SunGraphics2D.PAINT_OPAQUECOLOR &&
416 sg2d.surfaceData.getTransparency() == Transparency.OPAQUE;
417 }
418
419 public void validatePipe(SunGraphics2D sg2d) {
420 TextPipe textpipe;
421 boolean validated = false;
422
423 // OGLTextRenderer handles both AA and non-AA text, but
424 // only works with the following modes:
425 // (Note: For LCD text we only enter this code path if
426 // canRenderLCDText() has already validated that the mode is
427 // CompositeType.SrcNoEa (opaque color), which will be subsumed
428 // by the CompositeType.SrcNoEa (any color) test below.)
429
430 if (/* CompositeType.SrcNoEa (any color) */
431 (sg2d.compositeState <= sg2d.COMP_ISCOPY &&
432 sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) ||
433
434 /* CompositeType.SrcOver (any color) */
435 (sg2d.compositeState == sg2d.COMP_ALPHA &&
436 sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&
437 (((AlphaComposite)sg2d.composite).getRule() ==
438 AlphaComposite.SRC_OVER)) ||
439
440 /* CompositeType.Xor (any color) */
441 (sg2d.compositeState == sg2d.COMP_XOR &&
442 sg2d.paintState <= sg2d.PAINT_ALPHACOLOR))
443 {
444 textpipe = oglTextPipe;
445 } else {
446 // do this to initialize textpipe correctly; we will attempt
447 // to override the non-text pipes below
448 super.validatePipe(sg2d);
449 textpipe = sg2d.textpipe;
450 validated = true;
451 }
452
453 PixelToParallelogramConverter txPipe = null;
454 OGLRenderer nonTxPipe = null;
455
456 if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {
457 if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) {
458 if (sg2d.compositeState <= sg2d.COMP_XOR) {
459 txPipe = oglTxRenderPipe;
460 nonTxPipe = oglRenderPipe;
461 }
462 } else if (sg2d.compositeState <= sg2d.COMP_ALPHA) {
463 if (OGLPaints.isValid(sg2d)) {
464 txPipe = oglTxRenderPipe;
465 nonTxPipe = oglRenderPipe;
466 }
467 // custom paints handled by super.validatePipe() below
468 }
469 } else {
470 if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) {
471 if (graphicsConfig.isCapPresent(CAPS_PS30) &&
472 (sg2d.imageComp == CompositeType.SrcOverNoEa ||
473 sg2d.imageComp == CompositeType.SrcOver))
474 {
475 if (!validated) {
476 super.validatePipe(sg2d);
477 validated = true;
478 }
479 PixelToParallelogramConverter aaConverter =
480 new PixelToParallelogramConverter(sg2d.shapepipe,
481 oglAAPgramPipe,
482 1.0/8.0, 0.499,
483 false);
484 sg2d.drawpipe = aaConverter;
485 sg2d.fillpipe = aaConverter;
486 sg2d.shapepipe = aaConverter;
487 } else if (sg2d.compositeState == sg2d.COMP_XOR) {
488 // install the solid pipes when AA and XOR are both enabled
489 txPipe = oglTxRenderPipe;
490 nonTxPipe = oglRenderPipe;
491 }
492 }
493 // other cases handled by super.validatePipe() below
494 }
495
496 if (txPipe != null) {
497 if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
498 sg2d.drawpipe = txPipe;
499 sg2d.fillpipe = txPipe;
500 } else if (sg2d.strokeState != sg2d.STROKE_THIN) {
501 sg2d.drawpipe = txPipe;
502 sg2d.fillpipe = nonTxPipe;
503 } else {
504 sg2d.drawpipe = nonTxPipe;
505 sg2d.fillpipe = nonTxPipe;
506 }
507 // Note that we use the transforming pipe here because it
508 // will examine the shape and possibly perform an optimized
509 // operation if it can be simplified. The simplifications
510 // will be valid for all STROKE and TRANSFORM types.
511 sg2d.shapepipe = txPipe;
512 } else {
513 if (!validated) {
514 super.validatePipe(sg2d);
515 }
516 }
517
518 // install the text pipe based on our earlier decision
519 sg2d.textpipe = textpipe;
520
521 // always override the image pipe with the specialized OGL pipe
522 sg2d.imagepipe = oglImagePipe;
523 }
524
525 @Override
526 protected MaskFill getMaskFill(SunGraphics2D sg2d) {
527 if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
528 /*
529 * We can only accelerate non-Color MaskFill operations if
530 * all of the following conditions hold true:
531 * - there is an implementation for the given paintState
532 * - the current Paint can be accelerated for this destination
533 * - multitexturing is available (since we need to modulate
534 * the alpha mask texture with the paint texture)
535 *
536 * In all other cases, we return null, in which case the
537 * validation code will choose a more general software-based loop.
538 */
539 if (!OGLPaints.isValid(sg2d) ||
540 !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
541 {
542 return null;
543 }
544 }
545 return super.getMaskFill(sg2d);
546 }
547
548 public boolean copyArea(SunGraphics2D sg2d,
549 int x, int y, int w, int h, int dx, int dy)
550 {
551 if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE &&
552 sg2d.compositeState < sg2d.COMP_XOR)
553 {
554 x += sg2d.transX;
555 y += sg2d.transY;
556
557 oglRenderPipe.copyArea(sg2d, x, y, w, h, dx, dy);
558
559 return true;
560 }
561 return false;
562 }
563
564 public void flush() {
565 invalidate();
566 OGLRenderQueue rq = OGLRenderQueue.getInstance();
567 rq.lock();
568 try {
569 // make sure we have a current context before
570 // disposing the native resources (e.g. texture object)
571 OGLContext.setScratchSurface(graphicsConfig);
572
573 RenderBuffer buf = rq.getBuffer();
574 rq.ensureCapacityAndAlignment(12, 4);
575 buf.putInt(FLUSH_SURFACE);
576 buf.putLong(getNativeOps());
577
578 // this call is expected to complete synchronously, so flush now
579 rq.flushNow();
580 } finally {
581 rq.unlock();
582 }
583 }
584
585 /**
586 * Disposes the native resources associated with the given OGLSurfaceData
587 * (referenced by the pData parameter). This method is invoked from
588 * the native Dispose() method from the Disposer thread when the
589 * Java-level OGLSurfaceData object is about to go away. Note that we
590 * also pass a reference to the native GLX/WGLGraphicsConfigInfo
591 * (pConfigInfo) for the purposes of making a context current.
592 */
593 static void dispose(long pData, long pConfigInfo) {
594 OGLRenderQueue rq = OGLRenderQueue.getInstance();
595 rq.lock();
596 try {
597 // make sure we have a current context before
598 // disposing the native resources (e.g. texture object)
599 OGLContext.setScratchSurface(pConfigInfo);
600
601 RenderBuffer buf = rq.getBuffer();
602 rq.ensureCapacityAndAlignment(12, 4);
603 buf.putInt(DISPOSE_SURFACE);
604 buf.putLong(pData);
605
606 // this call is expected to complete synchronously, so flush now
607 rq.flushNow();
608 } finally {
609 rq.unlock();
610 }
611 }
612
613 static void swapBuffers(long window) {
614 OGLRenderQueue rq = OGLRenderQueue.getInstance();
615 rq.lock();
616 try {
617 RenderBuffer buf = rq.getBuffer();
618 rq.ensureCapacityAndAlignment(12, 4);
619 buf.putInt(SWAP_BUFFERS);
620 buf.putLong(window);
621 rq.flushNow();
622 } finally {
623 rq.unlock();
624 }
625 }
626
627 /**
628 * Returns true if OpenGL textures can have non-power-of-two dimensions
629 * when using the basic GL_TEXTURE_2D target.
630 */
631 boolean isTexNonPow2Available() {
632 return graphicsConfig.isCapPresent(CAPS_TEXNONPOW2);
633 }
634
635 /**
636 * Returns true if OpenGL textures can have non-power-of-two dimensions
637 * when using the GL_TEXTURE_RECTANGLE_ARB target (only available when the
638 * GL_ARB_texture_rectangle extension is present).
639 */
640 boolean isTexRectAvailable() {
641 return graphicsConfig.isCapPresent(CAPS_EXT_TEXRECT);
642 }
643
644 public Rectangle getNativeBounds() {
645 OGLRenderQueue rq = OGLRenderQueue.getInstance();
646 rq.lock();
647 try {
648 return new Rectangle(nativeWidth, nativeHeight);
649 } finally {
650 rq.unlock();
651 }
652 }
653}