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/OGLBlitLoops.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/java2d/opengl/OGLBlitLoops.java+762−0
@@ -0,0 +1,762 @@
1/*
2 * Copyright (c) 2003, 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
26package sun.java2d.opengl;
27
28import java.awt.Composite;
29import java.awt.Transparency;
30import java.awt.geom.AffineTransform;
31import java.awt.image.AffineTransformOp;
32import java.awt.image.BufferedImage;
33import java.awt.image.BufferedImageOp;
34import java.lang.ref.WeakReference;
35import sun.java2d.SurfaceData;
36import sun.java2d.loops.Blit;
37import sun.java2d.loops.CompositeType;
38import sun.java2d.loops.GraphicsPrimitive;
39import sun.java2d.loops.GraphicsPrimitiveMgr;
40import sun.java2d.loops.ScaledBlit;
41import sun.java2d.loops.SurfaceType;
42import sun.java2d.loops.TransformBlit;
43import sun.java2d.pipe.Region;
44import sun.java2d.pipe.RenderBuffer;
45import sun.java2d.pipe.RenderQueue;
46import static sun.java2d.pipe.BufferedOpCodes.*;
47
48class OGLBlitLoops {
49
50 static void register() {
51 Blit blitIntArgbPreToSurface =
52 new OGLSwToSurfaceBlit(SurfaceType.IntArgbPre,
53 OGLSurfaceData.PF_INT_ARGB_PRE);
54 Blit blitIntArgbPreToTexture =
55 new OGLSwToTextureBlit(SurfaceType.IntArgbPre,
56 OGLSurfaceData.PF_INT_ARGB_PRE);
57
58 GraphicsPrimitive[] primitives = {
59 // surface->surface ops
60 new OGLSurfaceToSurfaceBlit(),
61 new OGLSurfaceToSurfaceScale(),
62 new OGLSurfaceToSurfaceTransform(),
63
64 // render-to-texture surface->surface ops
65 new OGLRTTSurfaceToSurfaceBlit(),
66 new OGLRTTSurfaceToSurfaceScale(),
67 new OGLRTTSurfaceToSurfaceTransform(),
68
69 // surface->sw ops
70 new OGLSurfaceToSwBlit(SurfaceType.IntArgb,
71 OGLSurfaceData.PF_INT_ARGB),
72
73 // sw->surface ops
74 blitIntArgbPreToSurface,
75 new OGLSwToSurfaceBlit(SurfaceType.IntRgb,
76 OGLSurfaceData.PF_INT_RGB),
77 new OGLSwToSurfaceBlit(SurfaceType.IntRgbx,
78 OGLSurfaceData.PF_INT_RGBX),
79 new OGLSwToSurfaceBlit(SurfaceType.IntBgr,
80 OGLSurfaceData.PF_INT_BGR),
81 new OGLSwToSurfaceBlit(SurfaceType.IntBgrx,
82 OGLSurfaceData.PF_INT_BGRX),
83 new OGLSwToSurfaceBlit(SurfaceType.ThreeByteBgr,
84 OGLSurfaceData.PF_3BYTE_BGR),
85 new OGLSwToSurfaceBlit(SurfaceType.Ushort565Rgb,
86 OGLSurfaceData.PF_USHORT_565_RGB),
87 new OGLSwToSurfaceBlit(SurfaceType.Ushort555Rgb,
88 OGLSurfaceData.PF_USHORT_555_RGB),
89 new OGLSwToSurfaceBlit(SurfaceType.Ushort555Rgbx,
90 OGLSurfaceData.PF_USHORT_555_RGBX),
91 new OGLSwToSurfaceBlit(SurfaceType.ByteGray,
92 OGLSurfaceData.PF_BYTE_GRAY),
93 new OGLSwToSurfaceBlit(SurfaceType.UshortGray,
94 OGLSurfaceData.PF_USHORT_GRAY),
95 new OGLGeneralBlit(OGLSurfaceData.OpenGLSurface,
96 CompositeType.AnyAlpha,
97 blitIntArgbPreToSurface),
98
99 new OGLSwToSurfaceScale(SurfaceType.IntRgb,
100 OGLSurfaceData.PF_INT_RGB),
101 new OGLSwToSurfaceScale(SurfaceType.IntRgbx,
102 OGLSurfaceData.PF_INT_RGBX),
103 new OGLSwToSurfaceScale(SurfaceType.IntBgr,
104 OGLSurfaceData.PF_INT_BGR),
105 new OGLSwToSurfaceScale(SurfaceType.IntBgrx,
106 OGLSurfaceData.PF_INT_BGRX),
107 new OGLSwToSurfaceScale(SurfaceType.ThreeByteBgr,
108 OGLSurfaceData.PF_3BYTE_BGR),
109 new OGLSwToSurfaceScale(SurfaceType.Ushort565Rgb,
110 OGLSurfaceData.PF_USHORT_565_RGB),
111 new OGLSwToSurfaceScale(SurfaceType.Ushort555Rgb,
112 OGLSurfaceData.PF_USHORT_555_RGB),
113 new OGLSwToSurfaceScale(SurfaceType.Ushort555Rgbx,
114 OGLSurfaceData.PF_USHORT_555_RGBX),
115 new OGLSwToSurfaceScale(SurfaceType.ByteGray,
116 OGLSurfaceData.PF_BYTE_GRAY),
117 new OGLSwToSurfaceScale(SurfaceType.UshortGray,
118 OGLSurfaceData.PF_USHORT_GRAY),
119 new OGLSwToSurfaceScale(SurfaceType.IntArgbPre,
120 OGLSurfaceData.PF_INT_ARGB_PRE),
121
122 new OGLSwToSurfaceTransform(SurfaceType.IntRgb,
123 OGLSurfaceData.PF_INT_RGB),
124 new OGLSwToSurfaceTransform(SurfaceType.IntRgbx,
125 OGLSurfaceData.PF_INT_RGBX),
126 new OGLSwToSurfaceTransform(SurfaceType.IntBgr,
127 OGLSurfaceData.PF_INT_BGR),
128 new OGLSwToSurfaceTransform(SurfaceType.IntBgrx,
129 OGLSurfaceData.PF_INT_BGRX),
130 new OGLSwToSurfaceTransform(SurfaceType.ThreeByteBgr,
131 OGLSurfaceData.PF_3BYTE_BGR),
132 new OGLSwToSurfaceTransform(SurfaceType.Ushort565Rgb,
133 OGLSurfaceData.PF_USHORT_565_RGB),
134 new OGLSwToSurfaceTransform(SurfaceType.Ushort555Rgb,
135 OGLSurfaceData.PF_USHORT_555_RGB),
136 new OGLSwToSurfaceTransform(SurfaceType.Ushort555Rgbx,
137 OGLSurfaceData.PF_USHORT_555_RGBX),
138 new OGLSwToSurfaceTransform(SurfaceType.ByteGray,
139 OGLSurfaceData.PF_BYTE_GRAY),
140 new OGLSwToSurfaceTransform(SurfaceType.UshortGray,
141 OGLSurfaceData.PF_USHORT_GRAY),
142 new OGLSwToSurfaceTransform(SurfaceType.IntArgbPre,
143 OGLSurfaceData.PF_INT_ARGB_PRE),
144
145 // texture->surface ops
146 new OGLTextureToSurfaceBlit(),
147 new OGLTextureToSurfaceScale(),
148 new OGLTextureToSurfaceTransform(),
149
150 // sw->texture ops
151 blitIntArgbPreToTexture,
152 new OGLSwToTextureBlit(SurfaceType.IntRgb,
153 OGLSurfaceData.PF_INT_RGB),
154 new OGLSwToTextureBlit(SurfaceType.IntRgbx,
155 OGLSurfaceData.PF_INT_RGBX),
156 new OGLSwToTextureBlit(SurfaceType.IntBgr,
157 OGLSurfaceData.PF_INT_BGR),
158 new OGLSwToTextureBlit(SurfaceType.IntBgrx,
159 OGLSurfaceData.PF_INT_BGRX),
160 new OGLSwToTextureBlit(SurfaceType.ThreeByteBgr,
161 OGLSurfaceData.PF_3BYTE_BGR),
162 new OGLSwToTextureBlit(SurfaceType.Ushort565Rgb,
163 OGLSurfaceData.PF_USHORT_565_RGB),
164 new OGLSwToTextureBlit(SurfaceType.Ushort555Rgb,
165 OGLSurfaceData.PF_USHORT_555_RGB),
166 new OGLSwToTextureBlit(SurfaceType.Ushort555Rgbx,
167 OGLSurfaceData.PF_USHORT_555_RGBX),
168 new OGLSwToTextureBlit(SurfaceType.ByteGray,
169 OGLSurfaceData.PF_BYTE_GRAY),
170 new OGLSwToTextureBlit(SurfaceType.UshortGray,
171 OGLSurfaceData.PF_USHORT_GRAY),
172 new OGLGeneralBlit(OGLSurfaceData.OpenGLTexture,
173 CompositeType.SrcNoEa,
174 blitIntArgbPreToTexture),
175 };
176 GraphicsPrimitiveMgr.register(primitives);
177 }
178
179 /**
180 * The following offsets are used to pack the parameters in
181 * createPackedParams(). (They are also used at the native level when
182 * unpacking the params.)
183 */
184 private static final int OFFSET_SRCTYPE = 16;
185 private static final int OFFSET_HINT = 8;
186 private static final int OFFSET_TEXTURE = 3;
187 private static final int OFFSET_RTT = 2;
188 private static final int OFFSET_XFORM = 1;
189 private static final int OFFSET_ISOBLIT = 0;
190
191 /**
192 * Packs the given parameters into a single int value in order to save
193 * space on the rendering queue.
194 */
195 private static int createPackedParams(boolean isoblit, boolean texture,
196 boolean rtt, boolean xform,
197 int hint, int srctype)
198 {
199 return
200 ((srctype << OFFSET_SRCTYPE) |
201 (hint << OFFSET_HINT ) |
202 ((texture ? 1 : 0) << OFFSET_TEXTURE) |
203 ((rtt ? 1 : 0) << OFFSET_RTT ) |
204 ((xform ? 1 : 0) << OFFSET_XFORM ) |
205 ((isoblit ? 1 : 0) << OFFSET_ISOBLIT));
206 }
207
208 /**
209 * Enqueues a BLIT operation with the given parameters. Note that the
210 * RenderQueue lock must be held before calling this method.
211 */
212 private static void enqueueBlit(RenderQueue rq,
213 SurfaceData src, SurfaceData dst,
214 int packedParams,
215 int sx1, int sy1,
216 int sx2, int sy2,
217 double dx1, double dy1,
218 double dx2, double dy2)
219 {
220 // assert rq.lock.isHeldByCurrentThread();
221 RenderBuffer buf = rq.getBuffer();
222 rq.ensureCapacityAndAlignment(72, 24);
223 buf.putInt(BLIT);
224 buf.putInt(packedParams);
225 buf.putInt(sx1).putInt(sy1);
226 buf.putInt(sx2).putInt(sy2);
227 buf.putDouble(dx1).putDouble(dy1);
228 buf.putDouble(dx2).putDouble(dy2);
229 buf.putLong(src.getNativeOps());
230 buf.putLong(dst.getNativeOps());
231 }
232
233 static void Blit(SurfaceData srcData, SurfaceData dstData,
234 Composite comp, Region clip,
235 AffineTransform xform, int hint,
236 int sx1, int sy1,
237 int sx2, int sy2,
238 double dx1, double dy1,
239 double dx2, double dy2,
240 int srctype, boolean texture)
241 {
242 int ctxflags = 0;
243 if (srcData.getTransparency() == Transparency.OPAQUE) {
244 ctxflags |= OGLContext.SRC_IS_OPAQUE;
245 }
246
247 OGLRenderQueue rq = OGLRenderQueue.getInstance();
248 rq.lock();
249 try {
250 // make sure the RenderQueue keeps a hard reference to the
251 // source (sysmem) SurfaceData to prevent it from being
252 // disposed while the operation is processed on the QFT
253 rq.addReference(srcData);
254
255 OGLSurfaceData oglDst = (OGLSurfaceData)dstData;
256 if (texture) {
257 // make sure we have a current context before uploading
258 // the sysmem data to the texture object
259 OGLGraphicsConfig gc = oglDst.getOGLGraphicsConfig();
260 OGLContext.setScratchSurface(gc);
261 } else {
262 OGLContext.validateContext(oglDst, oglDst,
263 clip, comp, xform, null, null,
264 ctxflags);
265 }
266
267 int packedParams = createPackedParams(false, texture,
268 false, xform != null,
269 hint, srctype);
270 enqueueBlit(rq, srcData, dstData,
271 packedParams,
272 sx1, sy1, sx2, sy2,
273 dx1, dy1, dx2, dy2);
274
275 // always flush immediately, since we (currently) have no means
276 // of tracking changes to the system memory surface
277 rq.flushNow();
278 } finally {
279 rq.unlock();
280 }
281 }
282
283 /**
284 * Note: The srcImg and biop parameters are only used when invoked
285 * from the OGLBufImgOps.renderImageWithOp() method; in all other cases,
286 * this method can be called with null values for those two parameters,
287 * and they will be effectively ignored.
288 */
289 static void IsoBlit(SurfaceData srcData, SurfaceData dstData,
290 BufferedImage srcImg, BufferedImageOp biop,
291 Composite comp, Region clip,
292 AffineTransform xform, int hint,
293 int sx1, int sy1,
294 int sx2, int sy2,
295 double dx1, double dy1,
296 double dx2, double dy2,
297 boolean texture)
298 {
299 int ctxflags = 0;
300 if (srcData.getTransparency() == Transparency.OPAQUE) {
301 ctxflags |= OGLContext.SRC_IS_OPAQUE;
302 }
303
304 OGLRenderQueue rq = OGLRenderQueue.getInstance();
305 rq.lock();
306 try {
307 OGLSurfaceData oglSrc = (OGLSurfaceData)srcData;
308 OGLSurfaceData oglDst = (OGLSurfaceData)dstData;
309 int srctype = oglSrc.getType();
310 boolean rtt;
311 OGLSurfaceData srcCtxData;
312 if (srctype == OGLSurfaceData.TEXTURE) {
313 // the source is a regular texture object; we substitute
314 // the destination surface for the purposes of making a
315 // context current
316 rtt = false;
317 srcCtxData = oglDst;
318 } else {
319 // the source is a pbuffer, backbuffer, or render-to-texture
320 // surface; we set rtt to true to differentiate this kind
321 // of surface from a regular texture object
322 rtt = true;
323 if (srctype == OGLSurfaceData.FBOBJECT) {
324 srcCtxData = oglDst;
325 } else {
326 srcCtxData = oglSrc;
327 }
328 }
329
330 OGLContext.validateContext(srcCtxData, oglDst,
331 clip, comp, xform, null, null,
332 ctxflags);
333
334 if (biop != null) {
335 OGLBufImgOps.enableBufImgOp(rq, oglSrc, srcImg, biop);
336 }
337
338 int packedParams = createPackedParams(true, texture,
339 rtt, xform != null,
340 hint, 0 /*unused*/);
341 enqueueBlit(rq, srcData, dstData,
342 packedParams,
343 sx1, sy1, sx2, sy2,
344 dx1, dy1, dx2, dy2);
345
346 if (biop != null) {
347 OGLBufImgOps.disableBufImgOp(rq, biop);
348 }
349
350 if (rtt && (oglDst.getType() == OGLSurfaceData.WINDOW)) {
351 // we only have to flush immediately when copying from a
352 // (non-texture) surface to the screen; otherwise Swing apps
353 // might appear unresponsive until the auto-flush completes
354 rq.flushNow();
355 }
356 } finally {
357 rq.unlock();
358 }
359 }
360}
361
362class OGLSurfaceToSurfaceBlit extends Blit {
363
364 OGLSurfaceToSurfaceBlit() {
365 super(OGLSurfaceData.OpenGLSurface,
366 CompositeType.AnyAlpha,
367 OGLSurfaceData.OpenGLSurface);
368 }
369
370 public void Blit(SurfaceData src, SurfaceData dst,
371 Composite comp, Region clip,
372 int sx, int sy, int dx, int dy, int w, int h)
373 {
374 OGLBlitLoops.IsoBlit(src, dst,
375 null, null,
376 comp, clip, null,
377 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
378 sx, sy, sx+w, sy+h,
379 dx, dy, dx+w, dy+h,
380 false);
381 }
382}
383
384class OGLSurfaceToSurfaceScale extends ScaledBlit {
385
386 OGLSurfaceToSurfaceScale() {
387 super(OGLSurfaceData.OpenGLSurface,
388 CompositeType.AnyAlpha,
389 OGLSurfaceData.OpenGLSurface);
390 }
391
392 public void Scale(SurfaceData src, SurfaceData dst,
393 Composite comp, Region clip,
394 int sx1, int sy1,
395 int sx2, int sy2,
396 double dx1, double dy1,
397 double dx2, double dy2)
398 {
399 OGLBlitLoops.IsoBlit(src, dst,
400 null, null,
401 comp, clip, null,
402 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
403 sx1, sy1, sx2, sy2,
404 dx1, dy1, dx2, dy2,
405 false);
406 }
407}
408
409class OGLSurfaceToSurfaceTransform extends TransformBlit {
410
411 OGLSurfaceToSurfaceTransform() {
412 super(OGLSurfaceData.OpenGLSurface,
413 CompositeType.AnyAlpha,
414 OGLSurfaceData.OpenGLSurface);
415 }
416
417 public void Transform(SurfaceData src, SurfaceData dst,
418 Composite comp, Region clip,
419 AffineTransform at, int hint,
420 int sx, int sy, int dx, int dy,
421 int w, int h)
422 {
423 OGLBlitLoops.IsoBlit(src, dst,
424 null, null,
425 comp, clip, at, hint,
426 sx, sy, sx+w, sy+h,
427 dx, dy, dx+w, dy+h,
428 false);
429 }
430}
431
432class OGLRTTSurfaceToSurfaceBlit extends Blit {
433
434 OGLRTTSurfaceToSurfaceBlit() {
435 super(OGLSurfaceData.OpenGLSurfaceRTT,
436 CompositeType.AnyAlpha,
437 OGLSurfaceData.OpenGLSurface);
438 }
439
440 public void Blit(SurfaceData src, SurfaceData dst,
441 Composite comp, Region clip,
442 int sx, int sy, int dx, int dy, int w, int h)
443 {
444 OGLBlitLoops.IsoBlit(src, dst,
445 null, null,
446 comp, clip, null,
447 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
448 sx, sy, sx+w, sy+h,
449 dx, dy, dx+w, dy+h,
450 true);
451 }
452}
453
454class OGLRTTSurfaceToSurfaceScale extends ScaledBlit {
455
456 OGLRTTSurfaceToSurfaceScale() {
457 super(OGLSurfaceData.OpenGLSurfaceRTT,
458 CompositeType.AnyAlpha,
459 OGLSurfaceData.OpenGLSurface);
460 }
461
462 public void Scale(SurfaceData src, SurfaceData dst,
463 Composite comp, Region clip,
464 int sx1, int sy1,
465 int sx2, int sy2,
466 double dx1, double dy1,
467 double dx2, double dy2)
468 {
469 OGLBlitLoops.IsoBlit(src, dst,
470 null, null,
471 comp, clip, null,
472 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
473 sx1, sy1, sx2, sy2,
474 dx1, dy1, dx2, dy2,
475 true);
476 }
477}
478
479class OGLRTTSurfaceToSurfaceTransform extends TransformBlit {
480
481 OGLRTTSurfaceToSurfaceTransform() {
482 super(OGLSurfaceData.OpenGLSurfaceRTT,
483 CompositeType.AnyAlpha,
484 OGLSurfaceData.OpenGLSurface);
485 }
486
487 public void Transform(SurfaceData src, SurfaceData dst,
488 Composite comp, Region clip,
489 AffineTransform at, int hint,
490 int sx, int sy, int dx, int dy, int w, int h)
491 {
492 OGLBlitLoops.IsoBlit(src, dst,
493 null, null,
494 comp, clip, at, hint,
495 sx, sy, sx+w, sy+h,
496 dx, dy, dx+w, dy+h,
497 true);
498 }
499}
500
501class OGLSurfaceToSwBlit extends Blit {
502
503 private int typeval;
504
505 // REMIND: destination will actually be opaque/premultiplied...
506 OGLSurfaceToSwBlit(SurfaceType dstType, int typeval) {
507 super(OGLSurfaceData.OpenGLSurface,
508 CompositeType.SrcNoEa,
509 dstType);
510 this.typeval = typeval;
511 }
512
513 public void Blit(SurfaceData src, SurfaceData dst,
514 Composite comp, Region clip,
515 int sx, int sy, int dx, int dy,
516 int w, int h)
517 {
518 OGLRenderQueue rq = OGLRenderQueue.getInstance();
519 rq.lock();
520 try {
521 // make sure the RenderQueue keeps a hard reference to the
522 // destination (sysmem) SurfaceData to prevent it from being
523 // disposed while the operation is processed on the QFT
524 rq.addReference(dst);
525
526 RenderBuffer buf = rq.getBuffer();
527 OGLContext.validateContext((OGLSurfaceData)src);
528
529 rq.ensureCapacityAndAlignment(48, 32);
530 buf.putInt(SURFACE_TO_SW_BLIT);
531 buf.putInt(sx).putInt(sy);
532 buf.putInt(dx).putInt(dy);
533 buf.putInt(w).putInt(h);
534 buf.putInt(typeval);
535 buf.putLong(src.getNativeOps());
536 buf.putLong(dst.getNativeOps());
537
538 // always flush immediately
539 rq.flushNow();
540 } finally {
541 rq.unlock();
542 }
543 }
544}
545
546class OGLSwToSurfaceBlit extends Blit {
547
548 private int typeval;
549
550 OGLSwToSurfaceBlit(SurfaceType srcType, int typeval) {
551 super(srcType,
552 CompositeType.AnyAlpha,
553 OGLSurfaceData.OpenGLSurface);
554 this.typeval = typeval;
555 }
556
557 public void Blit(SurfaceData src, SurfaceData dst,
558 Composite comp, Region clip,
559 int sx, int sy, int dx, int dy, int w, int h)
560 {
561 OGLBlitLoops.Blit(src, dst,
562 comp, clip, null,
563 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
564 sx, sy, sx+w, sy+h,
565 dx, dy, dx+w, dy+h,
566 typeval, false);
567 }
568}
569
570class OGLSwToSurfaceScale extends ScaledBlit {
571
572 private int typeval;
573
574 OGLSwToSurfaceScale(SurfaceType srcType, int typeval) {
575 super(srcType,
576 CompositeType.AnyAlpha,
577 OGLSurfaceData.OpenGLSurface);
578 this.typeval = typeval;
579 }
580
581 public void Scale(SurfaceData src, SurfaceData dst,
582 Composite comp, Region clip,
583 int sx1, int sy1,
584 int sx2, int sy2,
585 double dx1, double dy1,
586 double dx2, double dy2)
587 {
588 OGLBlitLoops.Blit(src, dst,
589 comp, clip, null,
590 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
591 sx1, sy1, sx2, sy2,
592 dx1, dy1, dx2, dy2,
593 typeval, false);
594 }
595}
596
597class OGLSwToSurfaceTransform extends TransformBlit {
598
599 private int typeval;
600
601 OGLSwToSurfaceTransform(SurfaceType srcType, int typeval) {
602 super(srcType,
603 CompositeType.AnyAlpha,
604 OGLSurfaceData.OpenGLSurface);
605 this.typeval = typeval;
606 }
607
608 public void Transform(SurfaceData src, SurfaceData dst,
609 Composite comp, Region clip,
610 AffineTransform at, int hint,
611 int sx, int sy, int dx, int dy, int w, int h)
612 {
613 OGLBlitLoops.Blit(src, dst,
614 comp, clip, at, hint,
615 sx, sy, sx+w, sy+h,
616 dx, dy, dx+w, dy+h,
617 typeval, false);
618 }
619}
620
621class OGLSwToTextureBlit extends Blit {
622
623 private int typeval;
624
625 OGLSwToTextureBlit(SurfaceType srcType, int typeval) {
626 super(srcType,
627 CompositeType.SrcNoEa,
628 OGLSurfaceData.OpenGLTexture);
629 this.typeval = typeval;
630 }
631
632 public void Blit(SurfaceData src, SurfaceData dst,
633 Composite comp, Region clip,
634 int sx, int sy, int dx, int dy, int w, int h)
635 {
636 OGLBlitLoops.Blit(src, dst,
637 comp, clip, null,
638 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
639 sx, sy, sx+w, sy+h,
640 dx, dy, dx+w, dy+h,
641 typeval, true);
642 }
643}
644
645class OGLTextureToSurfaceBlit extends Blit {
646
647 OGLTextureToSurfaceBlit() {
648 super(OGLSurfaceData.OpenGLTexture,
649 CompositeType.AnyAlpha,
650 OGLSurfaceData.OpenGLSurface);
651 }
652
653 public void Blit(SurfaceData src, SurfaceData dst,
654 Composite comp, Region clip,
655 int sx, int sy, int dx, int dy, int w, int h)
656 {
657 OGLBlitLoops.IsoBlit(src, dst,
658 null, null,
659 comp, clip, null,
660 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
661 sx, sy, sx+w, sy+h,
662 dx, dy, dx+w, dy+h,
663 true);
664 }
665}
666
667class OGLTextureToSurfaceScale extends ScaledBlit {
668
669 OGLTextureToSurfaceScale() {
670 super(OGLSurfaceData.OpenGLTexture,
671 CompositeType.AnyAlpha,
672 OGLSurfaceData.OpenGLSurface);
673 }
674
675 public void Scale(SurfaceData src, SurfaceData dst,
676 Composite comp, Region clip,
677 int sx1, int sy1,
678 int sx2, int sy2,
679 double dx1, double dy1,
680 double dx2, double dy2)
681 {
682 OGLBlitLoops.IsoBlit(src, dst,
683 null, null,
684 comp, clip, null,
685 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
686 sx1, sy1, sx2, sy2,
687 dx1, dy1, dx2, dy2,
688 true);
689 }
690}
691
692class OGLTextureToSurfaceTransform extends TransformBlit {
693
694 OGLTextureToSurfaceTransform() {
695 super(OGLSurfaceData.OpenGLTexture,
696 CompositeType.AnyAlpha,
697 OGLSurfaceData.OpenGLSurface);
698 }
699
700 public void Transform(SurfaceData src, SurfaceData dst,
701 Composite comp, Region clip,
702 AffineTransform at, int hint,
703 int sx, int sy, int dx, int dy,
704 int w, int h)
705 {
706 OGLBlitLoops.IsoBlit(src, dst,
707 null, null,
708 comp, clip, at, hint,
709 sx, sy, sx+w, sy+h,
710 dx, dy, dx+w, dy+h,
711 true);
712 }
713}
714
715/**
716 * This general Blit implemenation converts any source surface to an
717 * intermediate IntArgbPre surface, and then uses the more specific
718 * IntArgbPre->OpenGLSurface/Texture loop to get the intermediate
719 * (premultiplied) surface down to OpenGL.
720 */
721class OGLGeneralBlit extends Blit {
722
723 private Blit performop;
724 private WeakReference srcTmp;
725
726 OGLGeneralBlit(SurfaceType dstType,
727 CompositeType compType,
728 Blit performop)
729 {
730 super(SurfaceType.Any, compType, dstType);
731 this.performop = performop;
732 }
733
734 public synchronized void Blit(SurfaceData src, SurfaceData dst,
735 Composite comp, Region clip,
736 int sx, int sy, int dx, int dy,
737 int w, int h)
738 {
739 Blit convertsrc = Blit.getFromCache(src.getSurfaceType(),
740 CompositeType.SrcNoEa,
741 SurfaceType.IntArgbPre);
742
743 SurfaceData cachedSrc = null;
744 if (srcTmp != null) {
745 // use cached intermediate surface, if available
746 cachedSrc = (SurfaceData)srcTmp.get();
747 }
748
749 // convert source to IntArgbPre
750 src = convertFrom(convertsrc, src, sx, sy, w, h,
751 cachedSrc, BufferedImage.TYPE_INT_ARGB_PRE);
752
753 // copy IntArgbPre intermediate surface to OpenGL surface
754 performop.Blit(src, dst, comp, clip,
755 0, 0, dx, dy, w, h);
756
757 if (src != cachedSrc) {
758 // cache the intermediate surface
759 srcTmp = new WeakReference(src);
760 }
761 }
762}