Back to index...

	/*
	* Copyright (c) 2005, 2016, 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.pipe;

	import java.awt.AlphaComposite;
	import java.awt.Color;
	import java.awt.Composite;
	import java.awt.Paint;
	import java.awt.geom.AffineTransform;
	import sun.java2d.pipe.hw.AccelSurface;
	import sun.java2d.InvalidPipeException;
	import sun.java2d.SunGraphics2D;
	import sun.java2d.loops.XORComposite;
	import static sun.java2d.pipe.BufferedOpCodes.*;
	import static sun.java2d.pipe.BufferedRenderPipe.BYTES_PER_SPAN;

	import java.lang.annotation.Native;
	import java.lang.ref.Reference;
	import java.lang.ref.WeakReference;

	/**
	* Base context class for managing state in a single-threaded rendering
	* environment. Each state-setting operation (e.g. SET_COLOR) is added to
	* the provided RenderQueue, which will be processed at a later time by a
	* single thread. Note that the RenderQueue lock must be acquired before
	* calling the validate() method (or any other method in this class). See
	* the RenderQueue class comments for a sample usage scenario.
	*
	* @see RenderQueue
	*/
	public abstract class BufferedContext {

	/*
	* The following flags help the internals of validate() determine
	* the appropriate (meaning correct, or optimal) code path when
	* setting up the current context. The flags can be bitwise OR'd
	* together as needed.
	*/

	/**
	* Indicates that no flags are needed; take all default code paths.
	*/
	@Native public static final int NO_CONTEXT_FLAGS = (0 << 0);
	/**
	* Indicates that the source surface (or color value, if it is a simple
	* rendering operation) is opaque (has an alpha value of 1.0). If this
	* flag is present, it allows us to disable blending in certain
	* situations in order to improve performance.
	*/
	@Native public static final int SRC_IS_OPAQUE = (1 << 0);
	/**
	* Indicates that the operation uses an alpha mask, which may determine
	* the code path that is used when setting up the current paint state.
	*/
	@Native public static final int USE_MASK = (1 << 1);

	protected RenderQueue rq;
	protected RenderBuffer buf;

	/**
	* This is a reference to the most recently validated BufferedContext. If
	* this value is null, it means that there is no current context. It is
	* provided here so that validate() only needs to do a quick reference
	* check to see if the BufferedContext passed to that method is the same
	* as the one we've cached here.
	*/
	protected static BufferedContext currentContext;

	private Reference<AccelSurface> validSrcDataRef = new WeakReference<>(null);
	private Reference<AccelSurface> validDstDataRef = new WeakReference<>(null);
	private Reference<Region> validClipRef = new WeakReference<>(null);
	private Reference<Composite> validCompRef = new WeakReference<>(null);
	private Reference<Paint> validPaintRef = new WeakReference<>(null);
	// renamed from isValidatedPaintAColor as part of a work around for 6764257
	private boolean isValidatedPaintJustAColor;
	private int validatedRGB;
	private int validatedFlags;
	private boolean xformInUse;
	private AffineTransform transform;

	protected BufferedContext(RenderQueue rq) {
	this.rq = rq;
	this.buf = rq.getBuffer();
	}

	/**
	* Fetches the BufferedContextContext associated with the dst. surface
	* and validates the context using the given parameters. Most rendering
	* operations will call this method first in order to set the necessary
	* state before issuing rendering commands.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* It's assumed that the type of surfaces has been checked by the Renderer
	*
	* @throws InvalidPipeException if either src or dest surface is not valid
	* or lost
	* @see RenderQueue#lock
	* @see RenderQueue#unlock
	*/
	public static void validateContext(AccelSurface srcData,
	AccelSurface dstData,
	Region clip, Composite comp,
	AffineTransform xform,
	Paint paint, SunGraphics2D sg2d,
	int flags)
	{
	// assert rq.lock.isHeldByCurrentThread();
	BufferedContext context = dstData.getContext();
	context.validate(srcData, dstData,
	clip, comp, xform, paint, sg2d, flags);
	}

	/**
	* Fetches the BufferedContextassociated with the surface
	* and disables all context state settings.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* It's assumed that the type of surfaces has been checked by the Renderer
	*
	* @throws InvalidPipeException if the surface is not valid
	* or lost
	* @see RenderQueue#lock
	* @see RenderQueue#unlock
	*/
	public static void validateContext(AccelSurface surface) {
	// assert rt.lock.isHeldByCurrentThread();
	validateContext(surface, surface,
	null, null, null, null, null, NO_CONTEXT_FLAGS);
	}

	/**
	* Validates the given parameters against the current state for this
	* context. If this context is not current, it will be made current
	* for the given source and destination surfaces, and the viewport will
	* be updated. Then each part of the context state (clip, composite,
	* etc.) is checked against the previous value. If the value has changed
	* since the last call to validate(), it will be updated accordingly.
	*
	* Note that the SunGraphics2D parameter is only used for the purposes
	* of validating a (non-null) Paint parameter. In all other cases it
	* is safe to pass a null SunGraphics2D and it will be ignored.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* It's assumed that the type of surfaces has been checked by the Renderer
	*
	* @throws InvalidPipeException if either src or dest surface is not valid
	* or lost
	*/
	public void validate(AccelSurface srcData, AccelSurface dstData,
	Region clip, Composite comp,
	AffineTransform xform,
	Paint paint, SunGraphics2D sg2d, int flags)
	{
	// assert rq.lock.isHeldByCurrentThread();

	boolean updateClip = false;
	boolean updatePaint = false;

	if (!dstData.isValid() \|\|
	dstData.isSurfaceLost() \|\| srcData.isSurfaceLost())
	{
	invalidateContext();
	throw new InvalidPipeException("bounds changed or surface lost");
	}

	if (paint instanceof Color) {
	// REMIND: not 30-bit friendly
	int newRGB = ((Color)paint).getRGB();
	if (isValidatedPaintJustAColor) {
	if (newRGB != validatedRGB) {
	validatedRGB = newRGB;
	updatePaint = true;
	}
	} else {
	validatedRGB = newRGB;
	updatePaint = true;
	isValidatedPaintJustAColor = true;
	}
	} else if (validPaintRef.get() != paint) {
	updatePaint = true;
	// this should be set when we are switching from paint to color
	// in which case this condition will be true
	isValidatedPaintJustAColor = false;
	}

	final AccelSurface validatedSrcData = validSrcDataRef.get();
	final AccelSurface validatedDstData = validDstDataRef.get();
	if ((currentContext != this) \|\|
	(srcData != validatedSrcData) \|\|
	(dstData != validatedDstData))
	{
	if (dstData != validatedDstData) {
	// the clip is dependent on the destination surface, so we
	// need to update it if we have a new destination surface
	updateClip = true;
	}

	if (paint == null) {
	// make sure we update the color state (otherwise, it might
	// not be updated if this is the first time the context
	// is being validated)
	updatePaint = true;
	}

	// update the current source and destination surfaces
	setSurfaces(srcData, dstData);

	currentContext = this;
	validSrcDataRef = new WeakReference<>(srcData);
	validDstDataRef = new WeakReference<>(dstData);
	}

	// validate clip
	final Region validatedClip = validClipRef.get();
	if ((clip != validatedClip) \|\| updateClip) {
	if (clip != null) {
	if (updateClip \|\|
	validatedClip == null \|\|
	!(validatedClip.isRectangular() && clip.isRectangular()) \|\|
	((clip.getLoX() != validatedClip.getLoX() \|\|
	clip.getLoY() != validatedClip.getLoY() \|\|
	clip.getHiX() != validatedClip.getHiX() \|\|
	clip.getHiY() != validatedClip.getHiY())))
	{
	setClip(clip);
	}
	} else {
	resetClip();
	}
	validClipRef = new WeakReference<>(clip);
	}

	// validate composite (note that a change in the context flags
	// may require us to update the composite state, even if the
	// composite has not changed)
	if ((comp != validCompRef.get()) \|\| (flags != validatedFlags)) {
	if (comp != null) {
	setComposite(comp, flags);
	} else {
	resetComposite();
	}
	// the paint state is dependent on the composite state, so make
	// sure we update the color below
	updatePaint = true;
	validCompRef = new WeakReference<>(comp);
	validatedFlags = flags;
	}

	// validate transform
	boolean txChanged = false;
	if (xform == null) {
	if (xformInUse) {
	resetTransform();
	xformInUse = false;
	txChanged = true;
	} else if (sg2d != null && !sg2d.transform.equals(transform)) {
	txChanged = true;
	}
	if (sg2d != null && txChanged) {
	transform = new AffineTransform(sg2d.transform);
	}
	} else {
	setTransform(xform);
	xformInUse = true;
	txChanged = true;
	}
	// non-Color paints may require paint revalidation
	if (!isValidatedPaintJustAColor && txChanged) {
	updatePaint = true;
	}

	// validate paint
	if (updatePaint) {
	if (paint != null) {
	BufferedPaints.setPaint(rq, sg2d, paint, flags);
	} else {
	BufferedPaints.resetPaint(rq);
	}
	validPaintRef = new WeakReference<>(paint);
	}

	// mark dstData dirty
	// REMIND: is this really needed now? we do it in SunGraphics2D..
	dstData.markDirty();
	}

	/**
	* Invalidates the surfaces associated with this context. This is
	* useful when the context is no longer needed, and we want to break
	* the chain caused by these surface references.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* @see RenderQueue#lock
	* @see RenderQueue#unlock
	*/
	private void invalidateSurfaces() {
	validSrcDataRef.clear();
	validDstDataRef.clear();
	}

	private void setSurfaces(AccelSurface srcData,
	AccelSurface dstData)
	{
	// assert rq.lock.isHeldByCurrentThread();
	rq.ensureCapacityAndAlignment(20, 4);
	buf.putInt(SET_SURFACES);
	buf.putLong(srcData.getNativeOps());
	buf.putLong(dstData.getNativeOps());
	}

	private void resetClip() {
	// assert rq.lock.isHeldByCurrentThread();
	rq.ensureCapacity(4);
	buf.putInt(RESET_CLIP);
	}

	private void setClip(Region clip) {
	// assert rq.lock.isHeldByCurrentThread();
	if (clip.isRectangular()) {
	rq.ensureCapacity(20);
	buf.putInt(SET_RECT_CLIP);
	buf.putInt(clip.getLoX()).putInt(clip.getLoY());
	buf.putInt(clip.getHiX()).putInt(clip.getHiY());
	} else {
	rq.ensureCapacity(28); // so that we have room for at least a span
	buf.putInt(BEGIN_SHAPE_CLIP);
	buf.putInt(SET_SHAPE_CLIP_SPANS);
	// include a placeholder for the span count
	int countIndex = buf.position();
	buf.putInt(0);
	int spanCount = 0;
	int remainingSpans = buf.remaining() / BYTES_PER_SPAN;
	int span[] = new int[4];
	SpanIterator si = clip.getSpanIterator();
	while (si.nextSpan(span)) {
	if (remainingSpans == 0) {
	buf.putInt(countIndex, spanCount);
	rq.flushNow();
	buf.putInt(SET_SHAPE_CLIP_SPANS);
	countIndex = buf.position();
	buf.putInt(0);
	spanCount = 0;
	remainingSpans = buf.remaining() / BYTES_PER_SPAN;
	}
	buf.putInt(span[0]); // x1
	buf.putInt(span[1]); // y1
	buf.putInt(span[2]); // x2
	buf.putInt(span[3]); // y2
	spanCount++;
	remainingSpans--;
	}
	buf.putInt(countIndex, spanCount);
	rq.ensureCapacity(4);
	buf.putInt(END_SHAPE_CLIP);
	}
	}

	private void resetComposite() {
	// assert rq.lock.isHeldByCurrentThread();
	rq.ensureCapacity(4);
	buf.putInt(RESET_COMPOSITE);
	}

	private void setComposite(Composite comp, int flags) {
	// assert rq.lock.isHeldByCurrentThread();
	if (comp instanceof AlphaComposite) {
	AlphaComposite ac = (AlphaComposite)comp;
	rq.ensureCapacity(16);
	buf.putInt(SET_ALPHA_COMPOSITE);
	buf.putInt(ac.getRule());
	buf.putFloat(ac.getAlpha());
	buf.putInt(flags);
	} else if (comp instanceof XORComposite) {
	int xorPixel = ((XORComposite)comp).getXorPixel();
	rq.ensureCapacity(8);
	buf.putInt(SET_XOR_COMPOSITE);
	buf.putInt(xorPixel);
	} else {
	throw new InternalError("not yet implemented");
	}
	}

	private void resetTransform() {
	// assert rq.lock.isHeldByCurrentThread();
	rq.ensureCapacity(4);
	buf.putInt(RESET_TRANSFORM);
	}

	private void setTransform(AffineTransform xform) {
	// assert rq.lock.isHeldByCurrentThread();
	rq.ensureCapacityAndAlignment(52, 4);
	buf.putInt(SET_TRANSFORM);
	buf.putDouble(xform.getScaleX());
	buf.putDouble(xform.getShearY());
	buf.putDouble(xform.getShearX());
	buf.putDouble(xform.getScaleY());
	buf.putDouble(xform.getTranslateX());
	buf.putDouble(xform.getTranslateY());
	}

	/**
	* Resets this context's surfaces and all attributes.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* @see RenderQueue#lock
	* @see RenderQueue#unlock
	*/
	public void invalidateContext() {
	resetTransform();
	resetComposite();
	resetClip();
	BufferedPaints.resetPaint(rq);
	invalidateSurfaces();
	validCompRef.clear();
	validClipRef.clear();
	validPaintRef.clear();
	isValidatedPaintJustAColor = false;
	xformInUse = false;
	}

	/**
	* Returns a singleton {@code RenderQueue} object used by the rendering
	* pipeline.
	*
	* @return a render queue
	* @see RenderQueue
	*/
	public abstract RenderQueue getRenderQueue();

	/**
	* Saves the the state of this context.
	* It may reset the current context.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* @see RenderQueue#lock
	* @see RenderQueue#unlock
	*/
	public abstract void saveState();

	/**
	* Restores the native state of this context.
	* It may reset the current context.
	*
	* Note: must be called while the RenderQueue lock is held.
	*
	* @see RenderQueue#lock
	* @see RenderQueue#unlock
	*/
	public abstract void restoreState();
	}

Back to index...