< prev index next >

src/java.desktop/share/classes/sun/java2d/pipe/AAShapePipe.java

Print this page


   1 /*
   2  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package sun.java2d.pipe;
  26 
  27 import java.awt.BasicStroke;
  28 import java.awt.Rectangle;
  29 import java.awt.Shape;
  30 import java.awt.geom.Rectangle2D;

  31 import sun.awt.SunHints;
  32 import sun.java2d.SunGraphics2D;
  33 
  34 /**
  35  * This class is used to convert raw geometry into 8-bit alpha tiles
  36  * using an AATileGenerator for application by the next stage of
  37  * the pipeline.
  38  * This class sets up the Generator and computes the alpha tiles
  39  * and then passes them on to a CompositePipe object for painting.
  40  */
  41 public class AAShapePipe
  42     implements ShapeDrawPipe, ParallelogramPipe
  43 {
  44     static RenderingEngine renderengine = RenderingEngine.getInstance();
  45 
  46     // Per-thread TileState (~1K very small so do not use any Weak Reference)
  47     private static final ThreadLocal<TileState> tileStateThreadLocal =
  48             new ThreadLocal<TileState>() {
  49         @Override
  50         protected TileState initialValue() {
  51             return new TileState();
  52         }
  53     };
  54 
  55     CompositePipe outpipe;
  56 
  57     public AAShapePipe(CompositePipe pipe) {
  58         outpipe = pipe;
  59     }
  60 

  61     public void draw(SunGraphics2D sg, Shape s) {
  62         BasicStroke bs;
  63 
  64         if (sg.stroke instanceof BasicStroke) {
  65             bs = (BasicStroke) sg.stroke;
  66         } else {
  67             s = sg.stroke.createStrokedShape(s);
  68             bs = null;
  69         }
  70 
  71         renderPath(sg, s, bs);
  72     }
  73 

  74     public void fill(SunGraphics2D sg, Shape s) {
  75         renderPath(sg, s, null);
  76     }
  77 

  78     public void fillParallelogram(SunGraphics2D sg,
  79                                   double ux1, double uy1,
  80                                   double ux2, double uy2,
  81                                   double x, double y,
  82                                   double dx1, double dy1,
  83                                   double dx2, double dy2)
  84     {
  85         Region clip = sg.getCompClip();
  86         final TileState ts = tileStateThreadLocal.get();
  87         final int[] abox = ts.abox;

  88 
  89         AATileGenerator aatg =
  90             renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, 0, 0,
  91                                             clip, abox);
  92         if (aatg == null) {
  93             // Nothing to render
  94             return;



  95         }
  96 
  97         renderTiles(sg, ts.computeBBox(ux1, uy1, ux2, uy2), aatg, abox, ts);
  98     }
  99 

 100     public void drawParallelogram(SunGraphics2D sg,
 101                                   double ux1, double uy1,
 102                                   double ux2, double uy2,
 103                                   double x, double y,
 104                                   double dx1, double dy1,
 105                                   double dx2, double dy2,
 106                                   double lw1, double lw2)
 107     {
 108         Region clip = sg.getCompClip();
 109         final TileState ts = tileStateThreadLocal.get();
 110         final int[] abox = ts.abox;

 111 
 112         AATileGenerator aatg =
 113             renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, lw1, lw2,
 114                                             clip, abox);
 115         if (aatg == null) {
 116             // Nothing to render
 117             return;





 118         }
 119 
 120         // Note that bbox is of the original shape, not the wide path.
 121         // This is appropriate for handing to Paint methods...
 122         renderTiles(sg, ts.computeBBox(ux1, uy1, ux2, uy2), aatg, abox, ts);
 123     }
 124 
 125     public void renderPath(SunGraphics2D sg, Shape s, BasicStroke bs) {
 126         boolean adjust = (bs != null &&
 127                           sg.strokeHint != SunHints.INTVAL_STROKE_PURE);
 128         boolean thin = (sg.strokeState <= SunGraphics2D.STROKE_THINDASHED);
 129 
 130         Region clip = sg.getCompClip();
 131         final TileState ts = tileStateThreadLocal.get();
 132         final int[] abox = ts.abox;

 133 
 134         AATileGenerator aatg =
 135             renderengine.getAATileGenerator(s, sg.transform, clip,
 136                                             bs, thin, adjust, abox);
 137         if (aatg == null) {
 138             // Nothing to render
 139             return;


 140         }
 141 
 142         renderTiles(sg, s, aatg, abox, ts);
 143     }
 144 
 145     public void renderTiles(SunGraphics2D sg, Shape s,
 146                             AATileGenerator aatg, int abox[], TileState ts)

 147     {
 148         Object context = null;
 149         try {

 150             context = outpipe.startSequence(sg, s,
 151                                             ts.computeDevBox(abox),
 152                                             abox);
 153 






 154             final int tw = aatg.getTileWidth();
 155             final int th = aatg.getTileHeight();
 156 
 157             // get tile from thread local storage:
 158             final byte[] alpha = ts.getAlphaTile(tw * th);
 159             byte[] atile;
 160 
 161             for (int y = abox[1]; y < abox[3]; y += th) {
 162                 int h = Math.min(th, abox[3] - y);
 163 
 164                 for (int x = abox[0]; x < abox[2]; x += tw) {
 165                     int w = Math.min(tw, abox[2] - x);
 166 
 167                     int a = aatg.getTypicalAlpha();
 168                     if (a == 0x00 ||
 169                         outpipe.needTile(context, x, y, w, h) == false)
 170                     {
 171                         aatg.nextTile();
 172                         outpipe.skipTile(context, x, y);
 173                         continue;
 174                     }
 175                     if (a == 0xff) {
 176                         atile = null;
 177                         aatg.nextTile();
 178                     } else {
 179                         atile = alpha;
 180                         aatg.getAlpha(alpha, 0, tw);
 181                     }
 182 
 183                     outpipe.renderPathTile(context, atile, 0, tw,
 184                                            x, y, w, h);
 185                 }
 186             }
 187         } finally {
 188             aatg.dispose();
 189             if (context != null) {
 190                 outpipe.endSequence(context);
 191             }
 192         }
 193     }
 194 
 195     // Tile state used by AAShapePipe
 196     static final class TileState {
 197         // cached tile (32 x 32 tile by default)
 198         private byte[] theTile = new byte[32 * 32];
 199         // dirty aabox array
 200         final int[] abox = new int[4];
 201         // dirty bbox rectangle
 202         private final Rectangle dev = new Rectangle();
 203         // dirty bbox rectangle2D.Double
 204         private final Rectangle2D.Double bbox2D = new Rectangle2D.Double();
 205 
 206         byte[] getAlphaTile(int len) {
 207             byte[] t = theTile;
 208             if (t.length < len) {
 209                 // create a larger tile and may free current theTile (too small)
 210                 theTile = t = new byte[len];
 211             }
 212             return t;
 213         }
 214 
 215         Rectangle computeDevBox(final int[] abox) {
 216             final Rectangle box = this.dev;


 224         Rectangle2D computeBBox(double ux1, double uy1,
 225                                 double ux2, double uy2)
 226         {
 227             if ((ux2 -= ux1) < 0.0) {
 228                 ux1 += ux2;
 229                 ux2 = -ux2;
 230             }
 231             if ((uy2 -= uy1) < 0.0) {
 232                 uy1 += uy2;
 233                 uy2 = -uy2;
 234             }
 235             final Rectangle2D.Double box = this.bbox2D;
 236             box.x = ux1;
 237             box.y = uy1;
 238             box.width = ux2;
 239             box.height = uy2;
 240             return box;
 241         }
 242     }
 243 

















































 244 }
   1 /*
   2  * Copyright (c) 1997, 2016, 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 package sun.java2d.pipe;
  26 
  27 import java.awt.BasicStroke;
  28 import java.awt.Rectangle;
  29 import java.awt.Shape;
  30 import java.awt.geom.Rectangle2D;
  31 import java.util.concurrent.ConcurrentLinkedQueue;
  32 import sun.awt.SunHints;
  33 import sun.java2d.SunGraphics2D;
  34 
  35 /**
  36  * This class is used to convert raw geometry into 8-bit alpha tiles
  37  * using an AATileGenerator for application by the next stage of
  38  * the pipeline.
  39  * This class sets up the Generator and computes the alpha tiles
  40  * and then passes them on to a CompositePipe object for painting.
  41  */
  42 public final class AAShapePipe
  43     implements ShapeDrawPipe, ParallelogramPipe
  44 {
  45     static final RenderingEngine renderengine = RenderingEngine.getInstance();
  46 
  47     // Per-thread TileState (~1K very small so do not use any Weak Reference)
  48     private static final ReentrantThreadLocal<TileState> tileStateThreadLocal =
  49             new ReentrantThreadLocal<TileState>() {
  50         @Override
  51         protected TileState initialValue() {
  52             return new TileState();
  53         }
  54     };
  55 
  56     final CompositePipe outpipe;
  57 
  58     public AAShapePipe(CompositePipe pipe) {
  59         outpipe = pipe;
  60     }
  61 
  62     @Override
  63     public void draw(SunGraphics2D sg, Shape s) {
  64         final BasicStroke bs;
  65 
  66         if (sg.stroke instanceof BasicStroke) {
  67             bs = (BasicStroke) sg.stroke;
  68         } else {
  69             s = sg.stroke.createStrokedShape(s);
  70             bs = null;
  71         }
  72 
  73         renderPath(sg, s, bs);
  74     }
  75 
  76     @Override
  77     public void fill(SunGraphics2D sg, Shape s) {
  78         renderPath(sg, s, null);
  79     }
  80 
  81     @Override
  82     public void fillParallelogram(SunGraphics2D sg,
  83                                   double ux1, double uy1,
  84                                   double ux2, double uy2,
  85                                   double x, double y,
  86                                   double dx1, double dy1,
  87                                   double dx2, double dy2)
  88     {

  89         final TileState ts = tileStateThreadLocal.get();
  90         try {
  91             final int[] abox = ts.abox;
  92 
  93             final AATileGenerator aatg =
  94                 renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, 0, 0,
  95                                                 sg.getCompClip(), abox);
  96             if (aatg != null) {
  97                 renderTiles(sg, ts.computeBBox(ux1, uy1, ux2, uy2),
  98                             aatg, abox, ts);
  99             }
 100         } finally {
 101             tileStateThreadLocal.restore(ts);
 102         }


 103     }
 104 
 105     @Override
 106     public void drawParallelogram(SunGraphics2D sg,
 107                                   double ux1, double uy1,
 108                                   double ux2, double uy2,
 109                                   double x, double y,
 110                                   double dx1, double dy1,
 111                                   double dx2, double dy2,
 112                                   double lw1, double lw2)
 113     {

 114         final TileState ts = tileStateThreadLocal.get();
 115         try {
 116             final int[] abox = ts.abox;
 117 
 118             final AATileGenerator aatg =
 119                 renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, lw1,
 120                                                 lw2, sg.getCompClip(), abox);
 121             if (aatg != null) {
 122                 // Note that bbox is of the original shape, not the wide path.
 123                 // This is appropriate for handing to Paint methods...
 124                 renderTiles(sg, ts.computeBBox(ux1, uy1, ux2, uy2),
 125                             aatg, abox, ts);
 126             }
 127         } finally {
 128             tileStateThreadLocal.restore(ts);
 129         }




 130     }
 131 
 132     public void renderPath(SunGraphics2D sg, Shape s, BasicStroke bs) {
 133         final boolean adjust = (bs != null &&
 134                           sg.strokeHint != SunHints.INTVAL_STROKE_PURE);
 135         final boolean thin = (sg.strokeState <= SunGraphics2D.STROKE_THINDASHED);
 136 

 137         final TileState ts = tileStateThreadLocal.get();
 138         try {
 139             final int[] abox = ts.abox;
 140 
 141             final AATileGenerator aatg =
 142                 renderengine.getAATileGenerator(s, sg.transform, sg.getCompClip(),
 143                                                 bs, thin, adjust, abox);
 144             if (aatg != null) {
 145                 renderTiles(sg, s, aatg, abox, ts);
 146             }
 147         } finally {
 148             tileStateThreadLocal.restore(ts);
 149         }


 150     }
 151 
 152     public void renderTiles(SunGraphics2D sg, Shape s,
 153                             final AATileGenerator aatg,
 154                             final int[] abox, final TileState ts)
 155     {
 156         Object context = null;
 157         try {
 158             // reentrance: outpipe may also use AAShapePipe:
 159             context = outpipe.startSequence(sg, s,
 160                                             ts.computeDevBox(abox),
 161                                             abox);
 162 
 163             // copy of int[] abox as local variables for performance:
 164             final int x0 = abox[0];
 165             final int y0 = abox[1];
 166             final int x1 = abox[2];
 167             final int y1 = abox[3];
 168 
 169             final int tw = aatg.getTileWidth();
 170             final int th = aatg.getTileHeight();
 171 
 172             // get tile from thread local storage:
 173             final byte[] alpha = ts.getAlphaTile(tw * th);
 174             byte[] atile;
 175 
 176             for (int y = y0; y < y1; y += th) {
 177                 final int h = Math.min(th, y1 - y);
 178 
 179                 for (int x = x0; x < x1; x += tw) {
 180                     final int w = Math.min(tw, x1 - x);
 181 
 182                     final int a = aatg.getTypicalAlpha();
 183 
 184                     if (a == 0x00 || !outpipe.needTile(context, x, y, w, h)) {

 185                         aatg.nextTile();
 186                         outpipe.skipTile(context, x, y);
 187                         continue;
 188                     }
 189                     if (a == 0xff) {
 190                         atile = null;
 191                         aatg.nextTile();
 192                     } else {
 193                         atile = alpha;
 194                         aatg.getAlpha(alpha, 0, tw);
 195                     }
 196 
 197                     outpipe.renderPathTile(context, atile, 0, tw, x, y, w, h);

 198                 }
 199             }
 200         } finally {
 201             aatg.dispose();
 202             if (context != null) {
 203                 outpipe.endSequence(context);
 204             }
 205         }
 206     }
 207 
 208     // Tile state used by AAShapePipe
 209     static final class TileState extends ReentrantContext {
 210         // cached tile (32 x 32 tile by default)
 211         private byte[] theTile = new byte[32 * 32];
 212         // dirty aabox array
 213         final int[] abox = new int[4];
 214         // dirty bbox rectangle
 215         private final Rectangle dev = new Rectangle();
 216         // dirty bbox rectangle2D.Double
 217         private final Rectangle2D.Double bbox2D = new Rectangle2D.Double();
 218 
 219         byte[] getAlphaTile(int len) {
 220             byte[] t = theTile;
 221             if (t.length < len) {
 222                 // create a larger tile and may free current theTile (too small)
 223                 theTile = t = new byte[len];
 224             }
 225             return t;
 226         }
 227 
 228         Rectangle computeDevBox(final int[] abox) {
 229             final Rectangle box = this.dev;


 237         Rectangle2D computeBBox(double ux1, double uy1,
 238                                 double ux2, double uy2)
 239         {
 240             if ((ux2 -= ux1) < 0.0) {
 241                 ux1 += ux2;
 242                 ux2 = -ux2;
 243             }
 244             if ((uy2 -= uy1) < 0.0) {
 245                 uy1 += uy2;
 246                 uy2 = -uy2;
 247             }
 248             final Rectangle2D.Double box = this.bbox2D;
 249             box.x = ux1;
 250             box.y = uy1;
 251             box.width = ux2;
 252             box.height = uy2;
 253             return box;
 254         }
 255     }
 256 
 257     static class ReentrantThreadLocal<K extends ReentrantContext>
 258         extends ThreadLocal<K>
 259     {
 260         final static int DEPTH_UNDEFINED = 0;
 261         final static int DEPTH_TL = 1;
 262         final static int DEPTH_CLQ = 2;
 263 
 264         // ReentrantContext queue for child contexts
 265         private final ConcurrentLinkedQueue<K> ctxQueue
 266             = new ConcurrentLinkedQueue<K>();
 267 
 268         /**
 269          * Give a ReentrantContext instance from thread-local or CLQ storage
 270          * @return ReentrantContext instance
 271          */
 272         @Override
 273         public final K get() {
 274             K ctx = super.get();
 275             // Check reentrance:
 276             if (ctx.depth == ReentrantThreadLocal.DEPTH_UNDEFINED) {
 277                 ctx.depth = ReentrantThreadLocal.DEPTH_TL;
 278             } else {
 279                 // get or create another ReentrantContext from queue:
 280                 ctx = ctxQueue.poll();
 281                 if (ctx == null) {
 282                     // create a new ReentrantContext if none is available
 283                     ctx = initialValue();
 284                     ctx.depth = ReentrantThreadLocal.DEPTH_CLQ;
 285                 }
 286             }
 287             return ctx;
 288         }
 289 
 290         /**
 291          * Restore the given ReentrantContext instance for reuse
 292          * @param ctx ReentrantContext instance
 293          */
 294         public final void restore(final K ctx) {
 295             if (ctx.depth == ReentrantThreadLocal.DEPTH_TL) {
 296                 ctx.depth = ReentrantThreadLocal.DEPTH_UNDEFINED;
 297             } else {
 298                 ctxQueue.offer(ctx);
 299             }
 300         }
 301     }
 302 
 303     static class ReentrantContext {
 304         int depth = ReentrantThreadLocal.DEPTH_UNDEFINED;
 305     }
 306 }
< prev index next >