1 /*
2 * Copyright (c) 2019, 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 package sun.java2d.metal;
27
28 import sun.java2d.SurfaceData;
29 import sun.java2d.loops.*;
30 import sun.java2d.pipe.Region;
31 import sun.java2d.pipe.RenderBuffer;
32 import sun.java2d.pipe.RenderQueue;
33 import sun.java2d.pipe.hw.AccelSurface;
34
35 import java.awt.*;
36 import java.awt.geom.AffineTransform;
37 import java.awt.image.AffineTransformOp;
38 import java.awt.image.BufferedImage;
39 import java.awt.image.BufferedImageOp;
40 import java.lang.annotation.Native;
41 import java.lang.ref.WeakReference;
42
43 import static sun.java2d.pipe.BufferedOpCodes.BLIT;
44 import static sun.java2d.pipe.BufferedOpCodes.SURFACE_TO_SW_BLIT;
45
46 final class MTLBlitLoops {
47
48 static void register() {
49 Blit blitIntArgbPreToSurface =
50 new MTLSwToSurfaceBlit(SurfaceType.IntArgbPre,
51 MTLSurfaceData.PF_INT_ARGB_PRE);
52 Blit blitIntArgbPreToTexture =
53 new MTLSwToTextureBlit(SurfaceType.IntArgbPre,
54 MTLSurfaceData.PF_INT_ARGB_PRE);
55 TransformBlit transformBlitIntArgbPreToSurface =
56 new MTLSwToSurfaceTransform(SurfaceType.IntArgbPre,
57 MTLSurfaceData.PF_INT_ARGB_PRE);
58 MTLSurfaceToSwBlit blitSurfaceToIntArgbPre =
59 new MTLSurfaceToSwBlit(SurfaceType.IntArgbPre,
60 MTLSurfaceData.PF_INT_ARGB_PRE);
61
62 GraphicsPrimitive[] primitives = {
63 // surface->surface ops
64 new MTLSurfaceToSurfaceBlit(),
65 new MTLSurfaceToSurfaceScale(),
66 new MTLSurfaceToSurfaceTransform(),
67
68 // render-to-texture surface->surface ops
69 new MTLRTTSurfaceToSurfaceBlit(),
70 new MTLRTTSurfaceToSurfaceScale(),
71 new MTLRTTSurfaceToSurfaceTransform(),
72
73 // surface->sw ops
74 new MTLSurfaceToSwBlit(SurfaceType.IntArgb,
75 MTLSurfaceData.PF_INT_ARGB),
76 blitSurfaceToIntArgbPre,
77
78 // sw->surface ops
79 blitIntArgbPreToSurface,
80 new MTLSwToSurfaceBlit(SurfaceType.IntRgb,
81 MTLSurfaceData.PF_INT_RGB),
82 new MTLSwToSurfaceBlit(SurfaceType.IntRgbx,
83 MTLSurfaceData.PF_INT_RGBX),
84 new MTLSwToSurfaceBlit(SurfaceType.IntBgr,
85 MTLSurfaceData.PF_INT_BGR),
86 new MTLSwToSurfaceBlit(SurfaceType.IntBgrx,
87 MTLSurfaceData.PF_INT_BGRX),
88 new MTLSwToSurfaceBlit(SurfaceType.ThreeByteBgr,
89 MTLSurfaceData.PF_3BYTE_BGR),
90 new MTLSwToSurfaceBlit(SurfaceType.Ushort565Rgb,
91 MTLSurfaceData.PF_USHORT_565_RGB),
92 new MTLSwToSurfaceBlit(SurfaceType.Ushort555Rgb,
93 MTLSurfaceData.PF_USHORT_555_RGB),
94 new MTLSwToSurfaceBlit(SurfaceType.Ushort555Rgbx,
95 MTLSurfaceData.PF_USHORT_555_RGBX),
96 new MTLSwToSurfaceBlit(SurfaceType.ByteGray,
97 MTLSurfaceData.PF_BYTE_GRAY),
98 new MTLSwToSurfaceBlit(SurfaceType.UshortGray,
99 MTLSurfaceData.PF_USHORT_GRAY),
100 new MTLGeneralBlit(MTLSurfaceData.MTLSurface,
101 CompositeType.AnyAlpha,
102 blitIntArgbPreToSurface),
103
104 new MTLAnyCompositeBlit(MTLSurfaceData.MTLSurface,
105 blitSurfaceToIntArgbPre,
106 blitSurfaceToIntArgbPre,
107 blitIntArgbPreToSurface),
108 new MTLAnyCompositeBlit(SurfaceType.Any,
109 null,
110 blitSurfaceToIntArgbPre,
111 blitIntArgbPreToSurface),
112
113 new MTLSwToSurfaceScale(SurfaceType.IntRgb,
114 MTLSurfaceData.PF_INT_RGB),
115 new MTLSwToSurfaceScale(SurfaceType.IntRgbx,
116 MTLSurfaceData.PF_INT_RGBX),
117 new MTLSwToSurfaceScale(SurfaceType.IntBgr,
118 MTLSurfaceData.PF_INT_BGR),
119 new MTLSwToSurfaceScale(SurfaceType.IntBgrx,
120 MTLSurfaceData.PF_INT_BGRX),
121 new MTLSwToSurfaceScale(SurfaceType.ThreeByteBgr,
122 MTLSurfaceData.PF_3BYTE_BGR),
123 new MTLSwToSurfaceScale(SurfaceType.Ushort565Rgb,
124 MTLSurfaceData.PF_USHORT_565_RGB),
125 new MTLSwToSurfaceScale(SurfaceType.Ushort555Rgb,
126 MTLSurfaceData.PF_USHORT_555_RGB),
127 new MTLSwToSurfaceScale(SurfaceType.Ushort555Rgbx,
128 MTLSurfaceData.PF_USHORT_555_RGBX),
129 new MTLSwToSurfaceScale(SurfaceType.ByteGray,
130 MTLSurfaceData.PF_BYTE_GRAY),
131 new MTLSwToSurfaceScale(SurfaceType.UshortGray,
132 MTLSurfaceData.PF_USHORT_GRAY),
133 new MTLSwToSurfaceScale(SurfaceType.IntArgbPre,
134 MTLSurfaceData.PF_INT_ARGB_PRE),
135
136 new MTLSwToSurfaceTransform(SurfaceType.IntRgb,
137 MTLSurfaceData.PF_INT_RGB),
138 new MTLSwToSurfaceTransform(SurfaceType.IntRgbx,
139 MTLSurfaceData.PF_INT_RGBX),
140 new MTLSwToSurfaceTransform(SurfaceType.IntBgr,
141 MTLSurfaceData.PF_INT_BGR),
142 new MTLSwToSurfaceTransform(SurfaceType.IntBgrx,
143 MTLSurfaceData.PF_INT_BGRX),
144 new MTLSwToSurfaceTransform(SurfaceType.ThreeByteBgr,
145 MTLSurfaceData.PF_3BYTE_BGR),
146 new MTLSwToSurfaceTransform(SurfaceType.Ushort565Rgb,
147 MTLSurfaceData.PF_USHORT_565_RGB),
148 new MTLSwToSurfaceTransform(SurfaceType.Ushort555Rgb,
149 MTLSurfaceData.PF_USHORT_555_RGB),
150 new MTLSwToSurfaceTransform(SurfaceType.Ushort555Rgbx,
151 MTLSurfaceData.PF_USHORT_555_RGBX),
152 new MTLSwToSurfaceTransform(SurfaceType.ByteGray,
153 MTLSurfaceData.PF_BYTE_GRAY),
154 new MTLSwToSurfaceTransform(SurfaceType.UshortGray,
155 MTLSurfaceData.PF_USHORT_GRAY),
156 transformBlitIntArgbPreToSurface,
157
158 new MTLGeneralTransformedBlit(transformBlitIntArgbPreToSurface),
159
160 // texture->surface ops
161 new MTLTextureToSurfaceBlit(),
162 new MTLTextureToSurfaceScale(),
163 new MTLTextureToSurfaceTransform(),
164
165 // sw->texture ops
166 blitIntArgbPreToTexture,
167 new MTLSwToTextureBlit(SurfaceType.IntRgb,
168 MTLSurfaceData.PF_INT_RGB),
169 new MTLSwToTextureBlit(SurfaceType.IntRgbx,
170 MTLSurfaceData.PF_INT_RGBX),
171 new MTLSwToTextureBlit(SurfaceType.IntBgr,
172 MTLSurfaceData.PF_INT_BGR),
173 new MTLSwToTextureBlit(SurfaceType.IntBgrx,
174 MTLSurfaceData.PF_INT_BGRX),
175 new MTLSwToTextureBlit(SurfaceType.ThreeByteBgr,
176 MTLSurfaceData.PF_3BYTE_BGR),
177 new MTLSwToTextureBlit(SurfaceType.Ushort565Rgb,
178 MTLSurfaceData.PF_USHORT_565_RGB),
179 new MTLSwToTextureBlit(SurfaceType.Ushort555Rgb,
180 MTLSurfaceData.PF_USHORT_555_RGB),
181 new MTLSwToTextureBlit(SurfaceType.Ushort555Rgbx,
182 MTLSurfaceData.PF_USHORT_555_RGBX),
183 new MTLSwToTextureBlit(SurfaceType.ByteGray,
184 MTLSurfaceData.PF_BYTE_GRAY),
185 new MTLSwToTextureBlit(SurfaceType.UshortGray,
186 MTLSurfaceData.PF_USHORT_GRAY),
187 new MTLGeneralBlit(MTLSurfaceData.MTLTexture,
188 CompositeType.SrcNoEa,
189 blitIntArgbPreToTexture),
190 };
191 GraphicsPrimitiveMgr.register(primitives);
192 }
193
194 /**
195 * The following offsets are used to pack the parameters in
196 * createPackedParams(). (They are also used at the native level when
197 * unpacking the params.)
198 */
199 @Native private static final int OFFSET_SRCTYPE = 16;
200 @Native private static final int OFFSET_HINT = 8;
201 @Native private static final int OFFSET_TEXTURE = 3;
202 @Native private static final int OFFSET_RTT = 2;
203 @Native private static final int OFFSET_XFORM = 1;
204 @Native private static final int OFFSET_ISOBLIT = 0;
205
206 /**
207 * Packs the given parameters into a single int value in order to save
208 * space on the rendering queue.
209 */
210 private static int createPackedParams(boolean isoblit, boolean texture,
211 boolean rtt, boolean xform,
212 int hint, int srctype)
213 {
214 return
215 ((srctype << OFFSET_SRCTYPE) |
216 (hint << OFFSET_HINT ) |
217 ((texture ? 1 : 0) << OFFSET_TEXTURE) |
218 ((rtt ? 1 : 0) << OFFSET_RTT ) |
219 ((xform ? 1 : 0) << OFFSET_XFORM ) |
220 ((isoblit ? 1 : 0) << OFFSET_ISOBLIT));
221 }
222
223 /**
224 * Enqueues a BLIT operation with the given parameters. Note that the
225 * RenderQueue lock must be held before calling this method.
226 */
227 private static void enqueueBlit(RenderQueue rq,
228 SurfaceData src, SurfaceData dst,
229 int packedParams,
230 int sx1, int sy1,
231 int sx2, int sy2,
232 double dx1, double dy1,
233 double dx2, double dy2)
234 {
235 // assert rq.lock.isHeldByCurrentThread();
236 RenderBuffer buf = rq.getBuffer();
237 rq.ensureCapacityAndAlignment(72, 24);
238 buf.putInt(BLIT);
239 buf.putInt(packedParams);
240 buf.putInt(sx1).putInt(sy1);
241 buf.putInt(sx2).putInt(sy2);
242 buf.putDouble(dx1).putDouble(dy1);
243 buf.putDouble(dx2).putDouble(dy2);
244 buf.putLong(src.getNativeOps());
245 buf.putLong(dst.getNativeOps());
246 }
247
248 static void Blit(SurfaceData srcData, SurfaceData dstData,
249 Composite comp, Region clip,
250 AffineTransform xform, int hint,
251 int sx1, int sy1,
252 int sx2, int sy2,
253 double dx1, double dy1,
254 double dx2, double dy2,
255 int srctype, boolean texture)
256 {
257 int ctxflags = 0;
258 if (srcData.getTransparency() == Transparency.OPAQUE) {
259 ctxflags |= MTLContext.SRC_IS_OPAQUE;
260 }
261
262 MTLRenderQueue rq = MTLRenderQueue.getInstance();
263 rq.lock();
264 try {
265 // make sure the RenderQueue keeps a hard reference to the
266 // source (sysmem) SurfaceData to prevent it from being
267 // disposed while the operation is processed on the QFT
268 rq.addReference(srcData);
269
270 MTLSurfaceData oglDst = (MTLSurfaceData)dstData;
271 if (texture) {
272 // make sure we have a current context before uploading
273 // the sysmem data to the texture object
274 MTLGraphicsConfig gc = oglDst.getMTLGraphicsConfig();
275 MTLContext.setScratchSurface(gc);
276 } else {
277 MTLContext.validateContext(oglDst, oglDst,
278 clip, comp, xform, null, null,
279 ctxflags);
280 }
281
282 int packedParams = createPackedParams(false, texture,
283 false, xform != null,
284 hint, srctype);
285 enqueueBlit(rq, srcData, dstData,
286 packedParams,
287 sx1, sy1, sx2, sy2,
288 dx1, dy1, dx2, dy2);
289
290 // always flush immediately, since we (currently) have no means
291 // of tracking changes to the system memory surface
292 rq.flushNow();
293 } finally {
294 rq.unlock();
295 }
296 }
297
298 /**
299 * Note: The srcImg and biop parameters are only used when invoked
300 * from the MTLBufImgOps.renderImageWithOp() method; in all other cases,
301 * this method can be called with null values for those two parameters,
302 * and they will be effectively ignored.
303 */
304 static void IsoBlit(SurfaceData srcData, SurfaceData dstData,
305 BufferedImage srcImg, BufferedImageOp biop,
306 Composite comp, Region clip,
307 AffineTransform xform, int hint,
308 int sx1, int sy1,
309 int sx2, int sy2,
310 double dx1, double dy1,
311 double dx2, double dy2,
312 boolean texture)
313 {
314 int ctxflags = 0;
315 if (srcData.getTransparency() == Transparency.OPAQUE) {
316 ctxflags |= MTLContext.SRC_IS_OPAQUE;
317 }
318
319 MTLRenderQueue rq = MTLRenderQueue.getInstance();
320 rq.lock();
321 try {
322 MTLSurfaceData oglSrc = (MTLSurfaceData)srcData;
323 MTLSurfaceData oglDst = (MTLSurfaceData)dstData;
324 int srctype = oglSrc.getType();
325 boolean rtt;
326 MTLSurfaceData srcCtxData;
327 if (srctype == MTLSurfaceData.TEXTURE) {
328 // the source is a regular texture object; we substitute
329 // the destination surface for the purposes of making a
330 // context current
331 rtt = false;
332 srcCtxData = oglDst;
333 } else {
334 // the source is a pbuffer, backbuffer, or render-to-texture
335 // surface; we set rtt to true to differentiate this kind
336 // of surface from a regular texture object
337 rtt = true;
338 if (srctype == AccelSurface.RT_TEXTURE) {
339 srcCtxData = oglDst;
340 } else {
341 srcCtxData = oglSrc;
342 }
343 }
344
345 MTLContext.validateContext(srcCtxData, oglDst,
346 clip, comp, xform, null, null,
347 ctxflags);
348
349 if (biop != null) {
350 MTLBufImgOps.enableBufImgOp(rq, oglSrc, srcImg, biop);
351 }
352
353 int packedParams = createPackedParams(true, texture,
354 rtt, xform != null,
355 hint, 0 /*unused*/);
356 enqueueBlit(rq, srcData, dstData,
357 packedParams,
358 sx1, sy1, sx2, sy2,
359 dx1, dy1, dx2, dy2);
360
361 if (biop != null) {
362 MTLBufImgOps.disableBufImgOp(rq, biop);
363 }
364
365 if (rtt && oglDst.isOnScreen()) {
366 // we only have to flush immediately when copying from a
367 // (non-texture) surface to the screen; otherwise Swing apps
368 // might appear unresponsive until the auto-flush completes
369 rq.flushNow();
370 }
371 } finally {
372 rq.unlock();
373 }
374 }
375 }
376
377 class MTLSurfaceToSurfaceBlit extends Blit {
378
379 MTLSurfaceToSurfaceBlit() {
380 super(MTLSurfaceData.MTLSurface,
381 CompositeType.AnyAlpha,
382 MTLSurfaceData.MTLSurface);
383 }
384
385 public void Blit(SurfaceData src, SurfaceData dst,
386 Composite comp, Region clip,
387 int sx, int sy, int dx, int dy, int w, int h)
388 {
389 MTLBlitLoops.IsoBlit(src, dst,
390 null, null,
391 comp, clip, null,
392 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
393 sx, sy, sx+w, sy+h,
394 dx, dy, dx+w, dy+h,
395 false);
396 }
397 }
398
399 class MTLSurfaceToSurfaceScale extends ScaledBlit {
400
401 MTLSurfaceToSurfaceScale() {
402 super(MTLSurfaceData.MTLSurface,
403 CompositeType.AnyAlpha,
404 MTLSurfaceData.MTLSurface);
405 }
406
407 public void Scale(SurfaceData src, SurfaceData dst,
408 Composite comp, Region clip,
409 int sx1, int sy1,
410 int sx2, int sy2,
411 double dx1, double dy1,
412 double dx2, double dy2)
413 {
414 MTLBlitLoops.IsoBlit(src, dst,
415 null, null,
416 comp, clip, null,
417 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
418 sx1, sy1, sx2, sy2,
419 dx1, dy1, dx2, dy2,
420 false);
421 }
422 }
423
424 class MTLSurfaceToSurfaceTransform extends TransformBlit {
425
426 MTLSurfaceToSurfaceTransform() {
427 super(MTLSurfaceData.MTLSurface,
428 CompositeType.AnyAlpha,
429 MTLSurfaceData.MTLSurface);
430 }
431
432 public void Transform(SurfaceData src, SurfaceData dst,
433 Composite comp, Region clip,
434 AffineTransform at, int hint,
435 int sx, int sy, int dx, int dy,
436 int w, int h)
437 {
438 MTLBlitLoops.IsoBlit(src, dst,
439 null, null,
440 comp, clip, at, hint,
441 sx, sy, sx+w, sy+h,
442 dx, dy, dx+w, dy+h,
443 false);
444 }
445 }
446
447 class MTLRTTSurfaceToSurfaceBlit extends Blit {
448
449 MTLRTTSurfaceToSurfaceBlit() {
450 super(MTLSurfaceData.MTLSurfaceRTT,
451 CompositeType.AnyAlpha,
452 MTLSurfaceData.MTLSurface);
453 }
454
455 public void Blit(SurfaceData src, SurfaceData dst,
456 Composite comp, Region clip,
457 int sx, int sy, int dx, int dy, int w, int h)
458 {
459 MTLBlitLoops.IsoBlit(src, dst,
460 null, null,
461 comp, clip, null,
462 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
463 sx, sy, sx+w, sy+h,
464 dx, dy, dx+w, dy+h,
465 true);
466 }
467 }
468
469 class MTLRTTSurfaceToSurfaceScale extends ScaledBlit {
470
471 MTLRTTSurfaceToSurfaceScale() {
472 super(MTLSurfaceData.MTLSurfaceRTT,
473 CompositeType.AnyAlpha,
474 MTLSurfaceData.MTLSurface);
475 }
476
477 public void Scale(SurfaceData src, SurfaceData dst,
478 Composite comp, Region clip,
479 int sx1, int sy1,
480 int sx2, int sy2,
481 double dx1, double dy1,
482 double dx2, double dy2)
483 {
484 MTLBlitLoops.IsoBlit(src, dst,
485 null, null,
486 comp, clip, null,
487 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
488 sx1, sy1, sx2, sy2,
489 dx1, dy1, dx2, dy2,
490 true);
491 }
492 }
493
494 class MTLRTTSurfaceToSurfaceTransform extends TransformBlit {
495
496 MTLRTTSurfaceToSurfaceTransform() {
497 super(MTLSurfaceData.MTLSurfaceRTT,
498 CompositeType.AnyAlpha,
499 MTLSurfaceData.MTLSurface);
500 }
501
502 public void Transform(SurfaceData src, SurfaceData dst,
503 Composite comp, Region clip,
504 AffineTransform at, int hint,
505 int sx, int sy, int dx, int dy, int w, int h)
506 {
507 MTLBlitLoops.IsoBlit(src, dst,
508 null, null,
509 comp, clip, at, hint,
510 sx, sy, sx+w, sy+h,
511 dx, dy, dx+w, dy+h,
512 true);
513 }
514 }
515
516 final class MTLSurfaceToSwBlit extends Blit {
517
518 private final int typeval;
519 private WeakReference<SurfaceData> srcTmp;
520
521 // destination will actually be ArgbPre or Argb
522 MTLSurfaceToSwBlit(final SurfaceType dstType, final int typeval) {
523 super(MTLSurfaceData.MTLSurface,
524 CompositeType.SrcNoEa,
525 dstType);
526 this.typeval = typeval;
527 }
528
529 private synchronized void complexClipBlit(SurfaceData src, SurfaceData dst,
530 Composite comp, Region clip,
531 int sx, int sy, int dx, int dy,
532 int w, int h) {
533 SurfaceData cachedSrc = null;
534 if (srcTmp != null) {
535 // use cached intermediate surface, if available
536 cachedSrc = srcTmp.get();
537 }
538
539 // We can convert argb_pre data from MTL surface in two places:
540 // - During MTL surface -> SW blit
541 // - During SW -> SW blit
542 // The first one is faster when we use opaque MTL surface, because in
543 // this case we simply skip conversion and use color components as is.
544 // Because of this we align intermediate buffer type with type of
545 // destination not source.
546 final int type = typeval == MTLSurfaceData.PF_INT_ARGB_PRE ?
547 BufferedImage.TYPE_INT_ARGB_PRE :
548 BufferedImage.TYPE_INT_ARGB;
549
550 src = convertFrom(this, src, sx, sy, w, h, cachedSrc, type);
551
552 // copy intermediate SW to destination SW using complex clip
553 final Blit performop = Blit.getFromCache(src.getSurfaceType(),
554 CompositeType.SrcNoEa,
555 dst.getSurfaceType());
556 performop.Blit(src, dst, comp, clip, 0, 0, dx, dy, w, h);
557
558 if (src != cachedSrc) {
559 // cache the intermediate surface
560 srcTmp = new WeakReference<>(src);
561 }
562 }
563
564 public void Blit(SurfaceData src, SurfaceData dst,
565 Composite comp, Region clip,
566 int sx, int sy, int dx, int dy,
567 int w, int h)
568 {
569 if (clip != null) {
570 clip = clip.getIntersectionXYWH(dx, dy, w, h);
571 // At the end this method will flush the RenderQueue, we should exit
572 // from it as soon as possible.
573 if (clip.isEmpty()) {
574 return;
575 }
576 sx += clip.getLoX() - dx;
577 sy += clip.getLoY() - dy;
578 dx = clip.getLoX();
579 dy = clip.getLoY();
580 w = clip.getWidth();
581 h = clip.getHeight();
582
583 if (!clip.isRectangular()) {
584 complexClipBlit(src, dst, comp, clip, sx, sy, dx, dy, w, h);
585 return;
586 }
587 }
588
589 MTLRenderQueue rq = MTLRenderQueue.getInstance();
590 rq.lock();
591 try {
592 // make sure the RenderQueue keeps a hard reference to the
593 // destination (sysmem) SurfaceData to prevent it from being
594 // disposed while the operation is processed on the QFT
595 rq.addReference(dst);
596
597 RenderBuffer buf = rq.getBuffer();
598 MTLContext.validateContext((MTLSurfaceData)src);
599
600 rq.ensureCapacityAndAlignment(48, 32);
601 buf.putInt(SURFACE_TO_SW_BLIT);
602 buf.putInt(sx).putInt(sy);
603 buf.putInt(dx).putInt(dy);
604 buf.putInt(w).putInt(h);
605 buf.putInt(typeval);
606 buf.putLong(src.getNativeOps());
607 buf.putLong(dst.getNativeOps());
608
609 // always flush immediately
610 rq.flushNow();
611 } finally {
612 rq.unlock();
613 }
614 }
615 }
616
617 class MTLSwToSurfaceBlit extends Blit {
618
619 private int typeval;
620
621 MTLSwToSurfaceBlit(SurfaceType srcType, int typeval) {
622 super(srcType,
623 CompositeType.AnyAlpha,
624 MTLSurfaceData.MTLSurface);
625 this.typeval = typeval;
626 }
627
628 public void Blit(SurfaceData src, SurfaceData dst,
629 Composite comp, Region clip,
630 int sx, int sy, int dx, int dy, int w, int h)
631 {
632 MTLBlitLoops.Blit(src, dst,
633 comp, clip, null,
634 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
635 sx, sy, sx+w, sy+h,
636 dx, dy, dx+w, dy+h,
637 typeval, false);
638 }
639 }
640
641 class MTLSwToSurfaceScale extends ScaledBlit {
642
643 private int typeval;
644
645 MTLSwToSurfaceScale(SurfaceType srcType, int typeval) {
646 super(srcType,
647 CompositeType.AnyAlpha,
648 MTLSurfaceData.MTLSurface);
649 this.typeval = typeval;
650 }
651
652 public void Scale(SurfaceData src, SurfaceData dst,
653 Composite comp, Region clip,
654 int sx1, int sy1,
655 int sx2, int sy2,
656 double dx1, double dy1,
657 double dx2, double dy2)
658 {
659 MTLBlitLoops.Blit(src, dst,
660 comp, clip, null,
661 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
662 sx1, sy1, sx2, sy2,
663 dx1, dy1, dx2, dy2,
664 typeval, false);
665 }
666 }
667
668 class MTLSwToSurfaceTransform extends TransformBlit {
669
670 private int typeval;
671
672 MTLSwToSurfaceTransform(SurfaceType srcType, int typeval) {
673 super(srcType,
674 CompositeType.AnyAlpha,
675 MTLSurfaceData.MTLSurface);
676 this.typeval = typeval;
677 }
678
679 public void Transform(SurfaceData src, SurfaceData dst,
680 Composite comp, Region clip,
681 AffineTransform at, int hint,
682 int sx, int sy, int dx, int dy, int w, int h)
683 {
684 MTLBlitLoops.Blit(src, dst,
685 comp, clip, at, hint,
686 sx, sy, sx+w, sy+h,
687 dx, dy, dx+w, dy+h,
688 typeval, false);
689 }
690 }
691
692 class MTLSwToTextureBlit extends Blit {
693
694 private int typeval;
695
696 MTLSwToTextureBlit(SurfaceType srcType, int typeval) {
697 super(srcType,
698 CompositeType.SrcNoEa,
699 MTLSurfaceData.MTLTexture);
700 this.typeval = typeval;
701 }
702
703 public void Blit(SurfaceData src, SurfaceData dst,
704 Composite comp, Region clip,
705 int sx, int sy, int dx, int dy, int w, int h)
706 {
707 MTLBlitLoops.Blit(src, dst,
708 comp, clip, null,
709 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
710 sx, sy, sx+w, sy+h,
711 dx, dy, dx+w, dy+h,
712 typeval, true);
713 }
714 }
715
716 class MTLTextureToSurfaceBlit extends Blit {
717
718 MTLTextureToSurfaceBlit() {
719 super(MTLSurfaceData.MTLTexture,
720 CompositeType.AnyAlpha,
721 MTLSurfaceData.MTLSurface);
722 }
723
724 public void Blit(SurfaceData src, SurfaceData dst,
725 Composite comp, Region clip,
726 int sx, int sy, int dx, int dy, int w, int h)
727 {
728 MTLBlitLoops.IsoBlit(src, dst,
729 null, null,
730 comp, clip, null,
731 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
732 sx, sy, sx+w, sy+h,
733 dx, dy, dx+w, dy+h,
734 true);
735 }
736 }
737
738 class MTLTextureToSurfaceScale extends ScaledBlit {
739
740 MTLTextureToSurfaceScale() {
741 super(MTLSurfaceData.MTLTexture,
742 CompositeType.AnyAlpha,
743 MTLSurfaceData.MTLSurface);
744 }
745
746 public void Scale(SurfaceData src, SurfaceData dst,
747 Composite comp, Region clip,
748 int sx1, int sy1,
749 int sx2, int sy2,
750 double dx1, double dy1,
751 double dx2, double dy2)
752 {
753 MTLBlitLoops.IsoBlit(src, dst,
754 null, null,
755 comp, clip, null,
756 AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
757 sx1, sy1, sx2, sy2,
758 dx1, dy1, dx2, dy2,
759 true);
760 }
761 }
762
763 class MTLTextureToSurfaceTransform extends TransformBlit {
764
765 MTLTextureToSurfaceTransform() {
766 super(MTLSurfaceData.MTLTexture,
767 CompositeType.AnyAlpha,
768 MTLSurfaceData.MTLSurface);
769 }
770
771 public void Transform(SurfaceData src, SurfaceData dst,
772 Composite comp, Region clip,
773 AffineTransform at, int hint,
774 int sx, int sy, int dx, int dy,
775 int w, int h)
776 {
777 MTLBlitLoops.IsoBlit(src, dst,
778 null, null,
779 comp, clip, at, hint,
780 sx, sy, sx+w, sy+h,
781 dx, dy, dx+w, dy+h,
782 true);
783 }
784 }
785
786 /**
787 * This general Blit implementation converts any source surface to an
788 * intermediate IntArgbPre surface, and then uses the more specific
789 * IntArgbPre->MTLSurface/Texture loop to get the intermediate
790 * (premultiplied) surface down to OpenGL using simple blit.
791 */
792 class MTLGeneralBlit extends Blit {
793
794 private final Blit performop;
795 private WeakReference<SurfaceData> srcTmp;
796
797 MTLGeneralBlit(SurfaceType dstType,
798 CompositeType compType,
799 Blit performop)
800 {
801 super(SurfaceType.Any, compType, dstType);
802 this.performop = performop;
803 }
804
805 public synchronized void Blit(SurfaceData src, SurfaceData dst,
806 Composite comp, Region clip,
807 int sx, int sy, int dx, int dy,
808 int w, int h)
809 {
810 Blit convertsrc = Blit.getFromCache(src.getSurfaceType(),
811 CompositeType.SrcNoEa,
812 SurfaceType.IntArgbPre);
813
814 SurfaceData cachedSrc = null;
815 if (srcTmp != null) {
816 // use cached intermediate surface, if available
817 cachedSrc = srcTmp.get();
818 }
819
820 // convert source to IntArgbPre
821 src = convertFrom(convertsrc, src, sx, sy, w, h,
822 cachedSrc, BufferedImage.TYPE_INT_ARGB_PRE);
823
824 // copy IntArgbPre intermediate surface to OpenGL surface
825 performop.Blit(src, dst, comp, clip,
826 0, 0, dx, dy, w, h);
827
828 if (src != cachedSrc) {
829 // cache the intermediate surface
830 srcTmp = new WeakReference<>(src);
831 }
832 }
833 }
834
835 /**
836 * This general TransformedBlit implementation converts any source surface to an
837 * intermediate IntArgbPre surface, and then uses the more specific
838 * IntArgbPre->MTLSurface/Texture loop to get the intermediate
839 * (premultiplied) surface down to OpenGL using simple transformBlit.
840 */
841 final class MTLGeneralTransformedBlit extends TransformBlit {
842
843 private final TransformBlit performop;
844 private WeakReference<SurfaceData> srcTmp;
845
846 MTLGeneralTransformedBlit(final TransformBlit performop) {
847 super(SurfaceType.Any, CompositeType.AnyAlpha,
848 MTLSurfaceData.MTLSurface);
849 this.performop = performop;
850 }
851
852 @Override
853 public synchronized void Transform(SurfaceData src, SurfaceData dst,
854 Composite comp, Region clip,
855 AffineTransform at, int hint, int srcx,
856 int srcy, int dstx, int dsty, int width,
857 int height){
858 Blit convertsrc = Blit.getFromCache(src.getSurfaceType(),
859 CompositeType.SrcNoEa,
860 SurfaceType.IntArgbPre);
861 // use cached intermediate surface, if available
862 final SurfaceData cachedSrc = srcTmp != null ? srcTmp.get() : null;
863 // convert source to IntArgbPre
864 src = convertFrom(convertsrc, src, srcx, srcy, width, height, cachedSrc,
865 BufferedImage.TYPE_INT_ARGB_PRE);
866
867 // transform IntArgbPre intermediate surface to OpenGL surface
868 performop.Transform(src, dst, comp, clip, at, hint, 0, 0, dstx, dsty,
869 width, height);
870
871 if (src != cachedSrc) {
872 // cache the intermediate surface
873 srcTmp = new WeakReference<>(src);
874 }
875 }
876 }
877
878 /**
879 * This general MTLAnyCompositeBlit implementation can convert any source/target
880 * surface to an intermediate surface using convertsrc/convertdst loops, applies
881 * necessary composite operation, and then uses convertresult loop to get the
882 * intermediate surface down to OpenGL.
883 */
884 final class MTLAnyCompositeBlit extends Blit {
885
886 private WeakReference<SurfaceData> dstTmp;
887 private WeakReference<SurfaceData> srcTmp;
888 private final Blit convertsrc;
889 private final Blit convertdst;
890 private final Blit convertresult;
891
892 MTLAnyCompositeBlit(SurfaceType srctype, Blit convertsrc, Blit convertdst,
893 Blit convertresult) {
894 super(srctype, CompositeType.Any, MTLSurfaceData.MTLSurface);
895 this.convertsrc = convertsrc;
896 this.convertdst = convertdst;
897 this.convertresult = convertresult;
898 }
899
900 public synchronized void Blit(SurfaceData src, SurfaceData dst,
901 Composite comp, Region clip,
902 int sx, int sy, int dx, int dy,
903 int w, int h)
904 {
905 if (convertsrc != null) {
906 SurfaceData cachedSrc = null;
907 if (srcTmp != null) {
908 // use cached intermediate surface, if available
909 cachedSrc = srcTmp.get();
910 }
911 // convert source to IntArgbPre
912 src = convertFrom(convertsrc, src, sx, sy, w, h, cachedSrc,
913 BufferedImage.TYPE_INT_ARGB_PRE);
914 if (src != cachedSrc) {
915 // cache the intermediate surface
916 srcTmp = new WeakReference<>(src);
917 }
918 }
919
920 SurfaceData cachedDst = null;
921
922 if (dstTmp != null) {
923 // use cached intermediate surface, if available
924 cachedDst = dstTmp.get();
925 }
926
927 // convert destination to IntArgbPre
928 SurfaceData dstBuffer = convertFrom(convertdst, dst, dx, dy, w, h,
929 cachedDst, BufferedImage.TYPE_INT_ARGB_PRE);
930 Region bufferClip =
931 clip == null ? null : clip.getTranslatedRegion(-dx, -dy);
932
933 Blit performop = Blit.getFromCache(src.getSurfaceType(),
934 CompositeType.Any, dstBuffer.getSurfaceType());
935 performop.Blit(src, dstBuffer, comp, bufferClip, sx, sy, 0, 0, w, h);
936
937 if (dstBuffer != cachedDst) {
938 // cache the intermediate surface
939 dstTmp = new WeakReference<>(dstBuffer);
940 }
941 // now blit the buffer back to the destination
942 convertresult.Blit(dstBuffer, dst, AlphaComposite.Src, clip, 0, 0, dx,
943 dy, w, h);
944 }
945 }