JDK14/Java14源码在线阅读
/*
* Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.java2d.marlin;
import jdk.internal.misc.Unsafe;
/**
* An object used to cache pre-rendered complex paths.
*
* @see Renderer
*/
public final class MarlinCache implements MarlinConst {
static final boolean FORCE_RLE = MarlinProperties.isForceRLE();
static final boolean FORCE_NO_RLE = MarlinProperties.isForceNoRLE();
// minimum width to try using RLE encoding:
static final int RLE_MIN_WIDTH
= Math.max(BLOCK_SIZE, MarlinProperties.getRLEMinWidth());
// maximum width for RLE encoding:
// values are stored as int [x|alpha] where alpha is 8 bits
static final int RLE_MAX_WIDTH = 1 << (24 - 1);
// 4096 (pixels) alpha values (width) x 64 rows / 4 (tile) = 64K bytes
// x1 instead of 4 bytes (RLE) ie 1/4 capacity or average good RLE compression
static final long INITIAL_CHUNK_ARRAY = TILE_H * INITIAL_PIXEL_WIDTH >> 2; // 64K
// The alpha map used by this object (taken out of our map cache) to convert
// pixel coverage counts gotten from MarlinCache (which are in the range
// [0, maxalpha]) into alpha values, which are in [0,256).
static final byte[] ALPHA_MAP;
static final OffHeapArray ALPHA_MAP_UNSAFE;
static {
final byte[] _ALPHA_MAP = buildAlphaMap(MAX_AA_ALPHA);
ALPHA_MAP_UNSAFE = new OffHeapArray(_ALPHA_MAP, _ALPHA_MAP.length); // 1K
ALPHA_MAP =_ALPHA_MAP;
final Unsafe _unsafe = OffHeapArray.UNSAFE;
final long addr = ALPHA_MAP_UNSAFE.address;
for (int i = 0; i < _ALPHA_MAP.length; i++) {
_unsafe.putByte(addr + i, _ALPHA_MAP[i]);
}
}
int bboxX0, bboxY0, bboxX1, bboxY1;
// 1D dirty arrays
// row index in rowAAChunk[]
final long[] rowAAChunkIndex = new long[TILE_H];
// first pixel (inclusive) for each row
final int[] rowAAx0 = new int[TILE_H];
// last pixel (exclusive) for each row
final int[] rowAAx1 = new int[TILE_H];
// encoding mode (0=raw, 1=RLE encoding) for each row
final int[] rowAAEnc = new int[TILE_H];
// coded length (RLE encoding) for each row
final long[] rowAALen = new long[TILE_H];
// last position in RLE decoding for each row (getAlpha):
final long[] rowAAPos = new long[TILE_H];
// dirty off-heap array containing pixel coverages for (32) rows (packed)
// if encoding=raw, it contains alpha coverage values (val) as integer
// if encoding=RLE, it contains tuples (val, last x-coordinate exclusive)
// use rowAAx0/rowAAx1 to get row indices within this chunk
final OffHeapArray rowAAChunk;
// current position in rowAAChunk array
long rowAAChunkPos;
// touchedTile[i] is the sum of all the alphas in the tile with
// x=j*TILE_SIZE+bboxX0.
int[] touchedTile;
// per-thread renderer stats
final RendererStats rdrStats;
// touchedTile ref (clean)
private final IntArrayCache.Reference touchedTile_ref;
int tileMin, tileMax;
boolean useRLE = false;
MarlinCache(final IRendererContext rdrCtx) {
this.rdrStats = rdrCtx.stats();
rowAAChunk = rdrCtx.newOffHeapArray(INITIAL_CHUNK_ARRAY); // 64K
touchedTile_ref = rdrCtx.newCleanIntArrayRef(INITIAL_ARRAY); // 1K = 1 tile line
touchedTile = touchedTile_ref.initial;
// tile used marks:
tileMin = Integer.MAX_VALUE;
tileMax = Integer.MIN_VALUE;
}
void init(int minx, int miny, int maxx, int maxy)
{
// assert maxy >= miny && maxx >= minx;
bboxX0 = minx;
bboxY0 = miny;
bboxX1 = maxx;
bboxY1 = maxy;
final int width = (maxx - minx);
if (FORCE_NO_RLE) {
useRLE = false;
} else if (FORCE_RLE) {
useRLE = true;
} else {
// heuristics: use both bbox area and complexity
// ie number of primitives:
// fast check min and max width (maxx < 23bits):
useRLE = (width > RLE_MIN_WIDTH && width < RLE_MAX_WIDTH);
}
// the ceiling of (maxy - miny + 1) / TILE_SIZE;
final int nxTiles = (width + TILE_W) >> TILE_W_LG;
if (nxTiles > INITIAL_ARRAY) {
if (DO_STATS) {
rdrStats.stat_array_marlincache_touchedTile.add(nxTiles);
}
touchedTile = touchedTile_ref.getArray(nxTiles);
}
}
/**
* Disposes this cache:
* clean up before reusing this instance
*/
void dispose() {
// Reset touchedTile if needed:
resetTileLine(0);
if (DO_STATS) {
rdrStats.totalOffHeap += rowAAChunk.length;
}
// Return arrays:
touchedTile = touchedTile_ref.putArray(touchedTile, 0, 0); // already zero filled
// At last: resize back off-heap rowAA to initial size
if (rowAAChunk.length != INITIAL_CHUNK_ARRAY) {
// note: may throw OOME:
rowAAChunk.resize(INITIAL_CHUNK_ARRAY);
}
if (DO_CLEAN_DIRTY) {
// Force zero-fill dirty arrays:
rowAAChunk.fill(BYTE_0);
}
}
void resetTileLine(final int pminY) {
// update bboxY0 to process a complete tile line [0 - 32]
bboxY0 = pminY;
// reset current pos
if (DO_STATS) {
rdrStats.stat_cache_rowAAChunk.add(rowAAChunkPos);
}
rowAAChunkPos = 0L;
// Reset touchedTile:
if (tileMin != Integer.MAX_VALUE) {
if (DO_STATS) {
rdrStats.stat_cache_tiles.add(tileMax - tileMin);
}
// clean only dirty touchedTile:
if (tileMax == 1) {
touchedTile[0] = 0;
} else {
IntArrayCache.fill(touchedTile, tileMin, tileMax, 0);
}
// reset tile used marks:
tileMin = Integer.MAX_VALUE;
tileMax = Integer.MIN_VALUE;
}
if (DO_CLEAN_DIRTY) {
// Force zero-fill dirty arrays:
rowAAChunk.fill(BYTE_0);
}
}
void clearAARow(final int y) {
// process tile line [0 - 32]
final int row = y - bboxY0;
// update pixel range:
rowAAx0[row] = 0; // first pixel inclusive
rowAAx1[row] = 0; // last pixel exclusive
rowAAEnc[row] = 0; // raw encoding
// note: leave rowAAChunkIndex[row] undefined
// and rowAALen[row] & rowAAPos[row] (RLE)
}
/**
* Copy the given alpha data into the rowAA cache
* @param alphaRow alpha data to copy from
* @param y y pixel coordinate
* @param px0 first pixel inclusive x0
* @param px1 last pixel exclusive x1
*/
void copyAARowNoRLE(final int[] alphaRow, final int y,
final int px0, final int px1)
{
// skip useless pixels above boundary
final int px_bbox1 = FloatMath.min(px1, bboxX1);
if (DO_LOG_BOUNDS) {
MarlinUtils.logInfo("row = [" + px0 + " ... " + px_bbox1
+ " (" + px1 + ") [ for y=" + y);
}
final int row = y - bboxY0;
// update pixel range:
rowAAx0[row] = px0; // first pixel inclusive
rowAAx1[row] = px_bbox1; // last pixel exclusive
rowAAEnc[row] = 0; // raw encoding
// get current position (bytes):
final long pos = rowAAChunkPos;
// update row index to current position:
rowAAChunkIndex[row] = pos;
// determine need array size:
// for RLE encoding, position must be aligned to 4 bytes (int):
// align - 1 = 3 so add +3 and round-off by mask ~3 = -4
final long needSize = pos + ((px_bbox1 - px0 + 3) & -4);
// update next position (bytes):
rowAAChunkPos = needSize;
// update row data:
final OffHeapArray _rowAAChunk = rowAAChunk;
// ensure rowAAChunk capacity:
if (_rowAAChunk.length < needSize) {
expandRowAAChunk(needSize);
}
if (DO_STATS) {
rdrStats.stat_cache_rowAA.add(px_bbox1 - px0);
}
// rowAA contains only alpha values for range[x0; x1[
final int[] _touchedTile = touchedTile;
final int _TILE_SIZE_LG = TILE_W_LG;
final int from = px0 - bboxX0; // first pixel inclusive
final int to = px_bbox1 - bboxX0; // last pixel exclusive
final Unsafe _unsafe = OffHeapArray.UNSAFE;
final long SIZE_BYTE = 1L;
final long addr_alpha = ALPHA_MAP_UNSAFE.address;
long addr_off = _rowAAChunk.address + pos;
// compute alpha sum into rowAA:
for (int x = from, val = 0; x < to; x++) {
// alphaRow is in [0; MAX_COVERAGE]
val += alphaRow[x]; // [from; to[
// ensure values are in [0; MAX_AA_ALPHA] range
if (DO_AA_RANGE_CHECK) {
if (val < 0) {
MarlinUtils.logInfo("Invalid coverage = " + val);
val = 0;
}
if (val > MAX_AA_ALPHA) {
MarlinUtils.logInfo("Invalid coverage = " + val);
val = MAX_AA_ALPHA;
}
}
// store alpha sum (as byte):
if (val == 0) {
_unsafe.putByte(addr_off, (byte)0); // [0-255]
} else {
_unsafe.putByte(addr_off, _unsafe.getByte(addr_alpha + val)); // [0-255]
// update touchedTile
_touchedTile[x >> _TILE_SIZE_LG] += val;
}
addr_off += SIZE_BYTE;
}
// update tile used marks:
int tx = from >> _TILE_SIZE_LG; // inclusive
if (tx < tileMin) {
tileMin = tx;
}
tx = ((to - 1) >> _TILE_SIZE_LG) + 1; // exclusive (+1 to be sure)
if (tx > tileMax) {
tileMax = tx;
}
if (DO_LOG_BOUNDS) {
MarlinUtils.logInfo("clear = [" + from + " ... " + to + "[");
}
// Clear alpha row for reuse:
IntArrayCache.fill(alphaRow, from, px1 + 1 - bboxX0, 0);
}
void copyAARowRLE_WithBlockFlags(final int[] blkFlags, final int[] alphaRow,
final int y, final int px0, final int px1)
{
// Copy rowAA data into the piscesCache if one is present
final int _bboxX0 = bboxX0;
// process tile line [0 - 32]
final int row = y - bboxY0;
final int from = px0 - _bboxX0; // first pixel inclusive
// skip useless pixels above boundary
final int px_bbox1 = FloatMath.min(px1, bboxX1);
final int to = px_bbox1 - _bboxX0; // last pixel exclusive
if (DO_LOG_BOUNDS) {
MarlinUtils.logInfo("row = [" + px0 + " ... " + px_bbox1
+ " (" + px1 + ") [ for y=" + y);
}
// get current position:
final long initialPos = startRLERow(row, px0, px_bbox1);
// determine need array size:
// pessimistic: max needed size = deltaX x 4 (1 int)
final long needSize = initialPos + ((to - from) << 2);
// update row data:
OffHeapArray _rowAAChunk = rowAAChunk;
// ensure rowAAChunk capacity:
if (_rowAAChunk.length < needSize) {
expandRowAAChunk(needSize);
}
final Unsafe _unsafe = OffHeapArray.UNSAFE;
final long SIZE_INT = 4L;
final long addr_alpha = ALPHA_MAP_UNSAFE.address;
long addr_off = _rowAAChunk.address + initialPos;
final int[] _touchedTile = touchedTile;
final int _TILE_SIZE_LG = TILE_W_LG;
final int _BLK_SIZE_LG = BLOCK_SIZE_LG;
// traverse flagged blocks:
final int blkW = (from >> _BLK_SIZE_LG);
final int blkE = (to >> _BLK_SIZE_LG) + 1;
// ensure last block flag = 0 to process final block:
blkFlags[blkE] = 0;
// Perform run-length encoding and store results in the piscesCache
int val = 0;
int cx0 = from;
int runLen;
final int _MAX_VALUE = Integer.MAX_VALUE;
int last_t0 = _MAX_VALUE;
int skip = 0;
for (int t = blkW, blk_x0, blk_x1, cx, delta; t <= blkE; t++) {
if (blkFlags[t] != 0) {
blkFlags[t] = 0;
if (last_t0 == _MAX_VALUE) {
last_t0 = t;
}
continue;
}
if (last_t0 != _MAX_VALUE) {
// emit blocks:
blk_x0 = FloatMath.max(last_t0 << _BLK_SIZE_LG, from);
last_t0 = _MAX_VALUE;
// (last block pixel+1) inclusive => +1
blk_x1 = FloatMath.min((t << _BLK_SIZE_LG) + 1, to);
for (cx = blk_x0; cx < blk_x1; cx++) {
if ((delta = alphaRow[cx]) != 0) {
alphaRow[cx] = 0;
// not first rle entry:
if (cx != cx0) {
runLen = cx - cx0;
// store alpha coverage (ensure within bounds):
// as [absX|val] where:
// absX is the absolute x-coordinate:
// note: last pixel exclusive (>= 0)
// note: it should check X is smaller than 23bits (overflow)!
// check address alignment to 4 bytes:
if (DO_CHECK_UNSAFE) {
if ((addr_off & 3) != 0) {
MarlinUtils.logInfo("Misaligned Unsafe address: " + addr_off);
}
}
// special case to encode entries into a single int:
if (val == 0) {
_unsafe.putInt(addr_off,
((_bboxX0 + cx) << 8)
);
} else {
_unsafe.putInt(addr_off,
((_bboxX0 + cx) << 8)
| (((int) _unsafe.getByte(addr_alpha + val)) & 0xFF) // [0-255]
);
if (runLen == 1) {
_touchedTile[cx0 >> _TILE_SIZE_LG] += val;
} else {
touchTile(cx0, val, cx, runLen, _touchedTile);
}
}
addr_off += SIZE_INT;
if (DO_STATS) {
rdrStats.hist_tile_generator_encoding_runLen
.add(runLen);
}
cx0 = cx;
}
// alpha value = running sum of coverage delta:
val += delta;
// ensure values are in [0; MAX_AA_ALPHA] range
if (DO_AA_RANGE_CHECK) {
if (val < 0) {
MarlinUtils.logInfo("Invalid coverage = " + val);
val = 0;
}
if (val > MAX_AA_ALPHA) {
MarlinUtils.logInfo("Invalid coverage = " + val);
val = MAX_AA_ALPHA;
}
}
}
}
} else if (DO_STATS) {
skip++;
}
}
// Process remaining RLE run:
runLen = to - cx0;
// store alpha coverage (ensure within bounds):
// as (int)[absX|val] where:
// absX is the absolute x-coordinate in bits 31 to 8 and val in bits 0..7
// note: last pixel exclusive (>= 0)
// note: it should check X is smaller than 23bits (overflow)!
// check address alignment to 4 bytes:
if (DO_CHECK_UNSAFE) {
if ((addr_off & 3) != 0) {
MarlinUtils.logInfo("Misaligned Unsafe address: " + addr_off);
}
}
// special case to encode entries into a single int:
if (val == 0) {
_unsafe.putInt(addr_off,
((_bboxX0 + to) << 8)
);
} else {
_unsafe.putInt(addr_off,
((_bboxX0 + to) << 8)
| (((int) _unsafe.getByte(addr_alpha + val)) & 0xFF) // [0-255]
);
if (runLen == 1) {
_touchedTile[cx0 >> _TILE_SIZE_LG] += val;
} else {
touchTile(cx0, val, to, runLen, _touchedTile);
}
}
addr_off += SIZE_INT;
if (DO_STATS) {
rdrStats.hist_tile_generator_encoding_runLen.add(runLen);
}
long len = (addr_off - _rowAAChunk.address);
// update coded length as bytes:
rowAALen[row] = (len - initialPos);
// update current position:
rowAAChunkPos = len;
if (DO_STATS) {
rdrStats.stat_cache_rowAA.add(rowAALen[row]);
rdrStats.hist_tile_generator_encoding_ratio.add(
(100 * skip) / (blkE - blkW)
);
}
// update tile used marks:
int tx = from >> _TILE_SIZE_LG; // inclusive
if (tx < tileMin) {
tileMin = tx;
}
tx = ((to - 1) >> _TILE_SIZE_LG) + 1; // exclusive (+1 to be sure)
if (tx > tileMax) {
tileMax = tx;
}
// Clear alpha row for reuse:
alphaRow[to] = 0;
if (DO_CHECKS) {
IntArrayCache.check(blkFlags, blkW, blkE, 0);
IntArrayCache.check(alphaRow, from, px1 + 1 - bboxX0, 0);
}
}
long startRLERow(final int row, final int x0, final int x1) {
// rows are supposed to be added by increasing y.
rowAAx0[row] = x0; // first pixel inclusive
rowAAx1[row] = x1; // last pixel exclusive
rowAAEnc[row] = 1; // RLE encoding
rowAAPos[row] = 0L; // position = 0
// update row index to current position:
return (rowAAChunkIndex[row] = rowAAChunkPos);
}
private void expandRowAAChunk(final long needSize) {
if (DO_STATS) {
rdrStats.stat_array_marlincache_rowAAChunk.add(needSize);
}
// note: throw IOOB if neededSize > 2Gb:
final long newSize = ArrayCacheConst.getNewLargeSize(rowAAChunk.length,
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java