1 /*

     2  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.java2d.jules;

    27 

    28 import java.awt.*;

    29 import java.awt.geom.*;

    30 import java.util.concurrent.*;

    31 import sun.java2d.pipe.*;

    32 import sun.java2d.xr.*;

    33 

    34 public class JulesAATileGenerator implements AATileGenerator {

    35     /* Threading stuff */

    36     static final ExecutorService rasterThreadPool =

    37                                           Executors.newCachedThreadPool();

    38     static final int CPU_CNT = Runtime.getRuntime().availableProcessors();

    39 

    40     static final boolean ENABLE_THREADING = false;

    41     static final int THREAD_MIN = 16;

    42     static final int THREAD_BEGIN = 16;

    43 

    44     IdleTileCache tileCache;

    45     TileWorker worker;

    46     boolean threaded = false;

    47     int rasterTileCnt;

    48 

    49     /* Tiling */

    50     static final int TILE_SIZE = 32;

    51     static final int TILE_SIZE_FP = 32 << 16;

    52     int left, right, top, bottom, width, height;

    53     int leftFP, topFP;

    54     int tileCnt, tilesX, tilesY;

    55     int currTilePos = 0;

    56     TrapezoidList traps;

    57     TileTrapContainer[] tiledTrapArray;

    58     JulesTile mainTile;

    59 

    60     public JulesAATileGenerator(Shape s, AffineTransform at, Region clip,

    61                                 BasicStroke bs, boolean thin,

    62                                 boolean normalize, int[] bbox) {

    63         JulesPathBuf buf = new JulesPathBuf();

    64 

    65         if (bs == null) {

    66             traps = buf.tesselateFill(s, at, clip);

    67         } else {

    68             traps = buf.tesselateStroke(s, bs, thin, false, true, at, clip);

    69         }

    70 

    71         calculateArea(bbox);

    72         bucketSortTraps();

    73         calculateTypicalAlpha();

    74 

    75         threaded = ENABLE_THREADING &&

    76                    rasterTileCnt >= THREAD_MIN && CPU_CNT >= 2;

    77         if (threaded) {

    78             tileCache = new IdleTileCache();

    79             worker = new TileWorker(this, THREAD_BEGIN, tileCache);

    80             rasterThreadPool.execute(worker);

    81         }

    82 

    83         mainTile = new JulesTile();

    84     }

    85 

    86     private static native long

    87         rasterizeTrapezoidsNative(long pixmanImagePtr, int[] traps,

    88                                   int[] trapPos, int trapCnt,

    89                                   byte[] buffer, int xOff, int yOff);

    90 

    91     private static native void freePixmanImgPtr(long pixmanImgPtr);

    92 

    93     private void calculateArea(int[] bbox) {

    94         tilesX = 0;

    95         tilesY = 0;

    96         tileCnt = 0;

    97         bbox[0] = 0;

    98         bbox[1] = 0;

    99         bbox[2] = 0;

   100         bbox[3] = 0;

   101 

   102         if (traps.getSize() > 0) {

   103             left = traps.getLeft();

   104             right = traps.getRight();

   105             top = traps.getTop();

   106             bottom = traps.getBottom();

   107             leftFP = left << 16;

   108             topFP = top << 16;

   109 

   110             bbox[0] = left;

   111             bbox[1] = top;

   112             bbox[2] = right;

   113             bbox[3] = bottom;

   114 

   115             width = right - left;

   116             height = bottom - top;

   117 

   118             if (width > 0 && height > 0) {

   119                 tilesX = (int) Math.ceil(((double) width) / TILE_SIZE);

   120                 tilesY = (int) Math.ceil(((double) height) / TILE_SIZE);

   121                 tileCnt = tilesY * tilesX;

   122                 tiledTrapArray = new TileTrapContainer[tileCnt];

   123             } else {

   124                 // If there is no area touched by the traps, don't

   125                 // render them.

   126                 traps.setSize(0);

   127             }

   128         }

   129     }

   130 

   131 

   132     private void bucketSortTraps() {

   133 

   134         for (int i = 0; i < traps.getSize(); i++) {

   135             int top = traps.getTop(i) - XRUtils.XDoubleToFixed(this.top);

   136             int bottom = traps.getBottom(i) - topFP;

   137             int p1xLeft = traps.getP1XLeft(i) - leftFP;

   138             int p2xLeft = traps.getP2XLeft(i) - leftFP;

   139             int p1xRight = traps.getP1XRight(i) - leftFP;

   140             int p2xRight = traps.getP2XRight(i) - leftFP;

   141 

   142             int minLeft = Math.min(p1xLeft, p2xLeft);

   143             int maxRight = Math.max(p1xRight, p2xRight);

   144 

   145             maxRight = maxRight > 0 ? maxRight - 1 : maxRight;

   146             bottom = bottom > 0 ? bottom - 1 : bottom;

   147 

   148             int startTileY = top / TILE_SIZE_FP;

   149             int endTileY = bottom / TILE_SIZE_FP;

   150             int startTileX = minLeft / TILE_SIZE_FP;

   151             int endTileX = maxRight / TILE_SIZE_FP;

   152 

   153             for (int n = startTileY; n <= endTileY; n++) {

   154 

   155                 for (int m = startTileX; m <= endTileX; m++) {

   156                     int trapArrayPos = n * tilesX + m;

   157                     TileTrapContainer trapTileList = tiledTrapArray[trapArrayPos];

   158                     if (trapTileList == null) {

   159                         trapTileList = new TileTrapContainer(new GrowableIntArray(1, 16));

   160                         tiledTrapArray[trapArrayPos] = trapTileList;

   161                     }

   162 

   163                     trapTileList.getTraps().addInt(i);

   164                 }

   165             }

   166         }

   167     }

   168 

   169     public void getAlpha(byte[] tileBuffer, int offset, int rowstride) {

   170         JulesTile tile = null;

   171 

   172         if (threaded) {

   173             tile = worker.getPreRasterizedTile(currTilePos);

   174         }

   175 

   176         if (tile != null) {

   177             System.arraycopy(tile.getImgBuffer(), 0,

   178                              tileBuffer, 0, tileBuffer.length);

   179             tileCache.releaseTile(tile);

   180         } else {

   181             mainTile.setImgBuffer(tileBuffer);

   182             rasterizeTile(currTilePos, mainTile);

   183         }

   184 

   185         nextTile();

   186     }

   187 

   188     public void calculateTypicalAlpha() {

   189         rasterTileCnt = 0;

   190 

   191         for (int index = 0; index < tileCnt; index++) {

   192 

   193             TileTrapContainer trapCont = tiledTrapArray[index];

   194             if (trapCont != null) {

   195                 GrowableIntArray trapList = trapCont.getTraps();

   196 

   197                 int tileAlpha = 127;

   198                 if (trapList == null || trapList.getSize() == 0) {

   199                     tileAlpha = 0;

   200                 } else if (doTrapsCoverTile(trapList, index)) {

   201                     tileAlpha = 0xff;

   202                 }

   203 

   204                 if (tileAlpha == 127 || tileAlpha == 0xff) {

   205                     rasterTileCnt++;

   206                 }

   207 

   208                 trapCont.setTileAlpha(tileAlpha);

   209             }

   210         }

   211     }

   212 

   213     /*

   214      * Optimization for large fills. Foutunatly cairo does generate an y-sorted

   215      * list of trapezoids. This makes it quite simple to check whether a tile is

   216      * fully covered by traps by: - Checking whether the tile is fully covered by

   217      * traps vertically (trap 2 starts where trap 1 ended) - Checking whether all

   218      * traps cover the tile horizontally This also works, when a single tile

   219      * coveres the whole tile.

   220      */

   221     protected boolean doTrapsCoverTile(GrowableIntArray trapList, int tileIndex) {

   222 

   223         // Don't bother optimizing tiles with lots of traps, usually it won't

   224         // succeed anyway.

   225         if (trapList.getSize() > TILE_SIZE) {

   226             return false;

   227         }

   228 

   229         int tileStartX = getXPos(tileIndex) * TILE_SIZE_FP + leftFP;

   230         int tileStartY = getYPos(tileIndex) * TILE_SIZE_FP + topFP;

   231         int tileEndX = tileStartX + TILE_SIZE_FP;

   232         int tileEndY = tileStartY + TILE_SIZE_FP;

   233 

   234         // Check whether first tile covers the beginning of the tile vertically

   235         int firstTop = traps.getTop(trapList.getInt(0));

   236         int firstBottom = traps.getBottom(trapList.getInt(0));

   237         if (firstTop > tileStartY || firstBottom < tileStartY) {

   238             return false;

   239         }

   240 

   241         // Initialize lastBottom with top, in order to pass the checks for the

   242         // first iteration

   243         int lastBottom = firstTop;

   244 

   245         for (int i = 0; i < trapList.getSize(); i++) {

   246             int trapPos = trapList.getInt(i);

   247             if (traps.getP1XLeft(trapPos) > tileStartX ||

   248                 traps.getP2XLeft(trapPos) > tileStartX ||

   249                 traps.getP1XRight(trapPos) < tileEndX  ||

   250                 traps.getP2XRight(trapPos) < tileEndX  ||

   251                  traps.getTop(trapPos) != lastBottom)

   252             {

   253                 return false;

   254             }

   255             lastBottom = traps.getBottom(trapPos);

   256         }

   257 

   258         // When the last trap covered the tileEnd vertically, the tile is fully

   259         // covered

   260         return lastBottom >= tileEndY;

   261     }

   262 

   263     public int getTypicalAlpha() {

   264         if (tiledTrapArray[currTilePos] == null) {

   265             return 0;

   266         } else {

   267             return tiledTrapArray[currTilePos].getTileAlpha();

   268         }

   269     }

   270 

   271     public void dispose() {

   272         freePixmanImgPtr(mainTile.getPixmanImgPtr());

   273 

   274         if (threaded) {

   275             tileCache.disposeConsumerResources();

   276             worker.disposeConsumerResources();

   277         }

   278     }

   279 

   280     protected JulesTile rasterizeTile(int tileIndex, JulesTile tile) {

   281         int tileOffsetX = left + getXPos(tileIndex) * TILE_SIZE;

   282         int tileOffsetY = top + getYPos(tileIndex) * TILE_SIZE;

   283         TileTrapContainer trapCont = tiledTrapArray[tileIndex];

   284         GrowableIntArray trapList = trapCont.getTraps();

   285 

   286         if (trapCont.getTileAlpha() == 127) {

   287             long pixmanImgPtr =

   288                  rasterizeTrapezoidsNative(tile.getPixmanImgPtr(),

   289                                            traps.getTrapArray(),

   290                                            trapList.getArray(),

   291                                            trapList.getSize(),

   292                                            tile.getImgBuffer(),

   293                                            tileOffsetX, tileOffsetY);

   294             tile.setPixmanImgPtr(pixmanImgPtr);

   295         }

   296 

   297         tile.setTilePos(tileIndex);

   298         return tile;

   299     }

   300 

   301     protected int getXPos(int arrayPos) {

   302         return arrayPos % tilesX;

   303     }

   304 

   305     protected int getYPos(int arrayPos) {

   306         return arrayPos / tilesX;

   307     }

   308 

   309     public void nextTile() {

   310         currTilePos++;

   311     }

   312 

   313     public int getTileHeight() {

   314         return TILE_SIZE;

   315     }

   316 

   317     public int getTileWidth() {

   318         return TILE_SIZE;

   319     }

   320 

   321     public int getTileCount() {

   322         return tileCnt;

   323     }

   324 

   325     public TileTrapContainer getTrapContainer(int index) {

   326         return tiledTrapArray[index];

   327     }

   328 }