Back to index...

	/*
	* Copyright (c) 1997, 2011, 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.
	*/

	/*
	* @author Charlton Innovations, Inc.
	*/

	package sun.java2d.loops;

	import java.awt.image.BufferedImage;
	import java.awt.AlphaComposite;
	import java.awt.Rectangle;
	import sun.awt.image.BufImgSurfaceData;
	import sun.java2d.SurfaceData;
	import sun.java2d.pipe.Region;
	import java.lang.reflect.Field;
	import java.util.StringTokenizer;
	import java.util.Iterator;
	import java.util.HashMap;
	import java.util.Map;
	import java.io.PrintStream;
	import java.io.OutputStream;
	import java.io.FileOutputStream;
	import java.io.FileNotFoundException;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import sun.security.action.GetPropertyAction;

	/**
	* defines interface for primitives which can be placed into
	* the graphic component manager framework
	*/
	public abstract class GraphicsPrimitive {

	protected static interface GeneralBinaryOp {
	/**
	* This method allows the setupGeneralBinaryOp method to set
	* the converters into the General version of the Primitive.
	*/
	public void setPrimitives(Blit srcconverter,
	Blit dstconverter,
	GraphicsPrimitive genericop,
	Blit resconverter);

	/**
	* These 4 methods are implemented automatically for any
	* GraphicsPrimitive. They are used by setupGeneralBinaryOp
	* to retrieve the information needed to find the right
	* converter primitives.
	*/
	public SurfaceType getSourceType();
	public CompositeType getCompositeType();
	public SurfaceType getDestType();
	public String getSignature();
	public int getPrimTypeID();
	}

	protected static interface GeneralUnaryOp {
	/**
	* This method allows the setupGeneralUnaryOp method to set
	* the converters into the General version of the Primitive.
	*/
	public void setPrimitives(Blit dstconverter,
	GraphicsPrimitive genericop,
	Blit resconverter);

	/**
	* These 3 methods are implemented automatically for any
	* GraphicsPrimitive. They are used by setupGeneralUnaryOp
	* to retrieve the information needed to find the right
	* converter primitives.
	*/
	public CompositeType getCompositeType();
	public SurfaceType getDestType();
	public String getSignature();
	public int getPrimTypeID();
	}

	/**
	* INSTANCE DATA MEMBERS DESCRIBING CHARACTERISTICS OF THIS PRIMITIVE
	**/

	// Making these be instance data members (instead of virtual methods
	// overridden by subclasses) is actually cheaper, since each class
	// is a singleton. As instance data members with final accessors,
	// accesses can be inlined.
	private String methodSignature;
	private int uniqueID;
	private static int unusedPrimID = 1;

	private SurfaceType sourceType;
	private CompositeType compositeType;
	private SurfaceType destType;

	private long pNativePrim; // Native blit loop info

	public synchronized static final int makePrimTypeID() {
	if (unusedPrimID > 255) {
	throw new InternalError("primitive id overflow");
	}
	return unusedPrimID++;
	}

	public synchronized static final int makeUniqueID(int primTypeID,
	SurfaceType src,
	CompositeType cmp,
	SurfaceType dst)
	{
	return (primTypeID << 24) \|
	(dst.getUniqueID() << 16) \|
	(cmp.getUniqueID() << 8) \|
	(src.getUniqueID());
	}

	/**
	* Create a new GraphicsPrimitive with all of the required
	* descriptive information.
	*/
	protected GraphicsPrimitive(String methodSignature,
	int primTypeID,
	SurfaceType sourceType,
	CompositeType compositeType,
	SurfaceType destType)
	{
	this.methodSignature = methodSignature;
	this.sourceType = sourceType;
	this.compositeType = compositeType;
	this.destType = destType;

	if(sourceType == null \|\| compositeType == null \|\| destType == null) {
	this.uniqueID = primTypeID << 24;
	} else {
	this.uniqueID = GraphicsPrimitive.makeUniqueID(primTypeID,
	sourceType,
	compositeType,
	destType);
	}
	}

	/**
	* Create a new GraphicsPrimitive for native invocation
	* with all of the required descriptive information.
	*/
	protected GraphicsPrimitive(long pNativePrim,
	String methodSignature,
	int primTypeID,
	SurfaceType sourceType,
	CompositeType compositeType,
	SurfaceType destType)
	{
	this.pNativePrim = pNativePrim;
	this.methodSignature = methodSignature;
	this.sourceType = sourceType;
	this.compositeType = compositeType;
	this.destType = destType;

	if(sourceType == null \|\| compositeType == null \|\| destType == null) {
	this.uniqueID = primTypeID << 24;
	} else {
	this.uniqueID = GraphicsPrimitive.makeUniqueID(primTypeID,
	sourceType,
	compositeType,
	destType);
	}
	}

	/**
	* METHODS TO DESCRIBE THE SURFACES PRIMITIVES
	* CAN OPERATE ON AND THE FUNCTIONALITY THEY IMPLEMENT
	**/

	/**
	* Gets instance ID of this graphics primitive.
	*
	* Instance ID is comprised of four distinct ids (ORed together)
	* that uniquely identify each instance of a GraphicsPrimitive
	* object. The four ids making up instance ID are:
	* 1. primitive id - identifier shared by all primitives of the
	* same type (eg. all Blits have the same primitive id)
	* 2. sourcetype id - identifies source surface type
	* 3. desttype id - identifies destination surface type
	* 4. compositetype id - identifies composite used
	*
	* @return instance ID
	*/
	public final int getUniqueID() {
	return uniqueID;
	}

	/**
	*/
	public final String getSignature() {
	return methodSignature;
	}

	/**
	* Gets unique id for this GraphicsPrimitive type.
	*
	* This id is used to identify the TYPE of primitive (Blit vs. BlitBg)
	* as opposed to INSTANCE of primitive.
	*
	* @return primitive ID
	*/
	public final int getPrimTypeID() {
	return uniqueID >>> 24;
	}

	/**
	*/
	public final long getNativePrim() {
	return pNativePrim;
	}

	/**
	*/
	public final SurfaceType getSourceType() {
	return sourceType;
	}

	/**
	*/
	public final CompositeType getCompositeType() {
	return compositeType;
	}

	/**
	*/
	public final SurfaceType getDestType() {
	return destType;
	}

	/**
	* Return true if this primitive can be used for the given signature
	* surfaces, and composite.
	*
	* @param signature The signature of the given operation. Must be
	* == (not just .equals) the signature string given by the
	* abstract class that declares the operation.
	* @param srctype The surface type for the source of the operation
	* @param comptype The composite type for the operation
	* @param dsttype The surface type for the destination of the operation
	*/
	public final boolean satisfies(String signature,
	SurfaceType srctype,
	CompositeType comptype,
	SurfaceType dsttype)
	{
	if (signature != methodSignature) {
	return false;
	}
	while (true) {
	if (srctype == null) {
	return false;
	}
	if (srctype.equals(sourceType)) {
	break;
	}
	srctype = srctype.getSuperType();
	}
	while (true) {
	if (comptype == null) {
	return false;
	}
	if (comptype.equals(compositeType)) {
	break;
	}
	comptype = comptype.getSuperType();
	}
	while (true) {
	if (dsttype == null) {
	return false;
	}
	if (dsttype.equals(destType)) {
	break;
	}
	dsttype = dsttype.getSuperType();
	}
	return true;
	}

	//
	// A version of satisfies used for regression testing
	//
	final boolean satisfiesSameAs(GraphicsPrimitive other) {
	return (methodSignature == other.methodSignature &&
	sourceType.equals(other.sourceType) &&
	compositeType.equals(other.compositeType) &&
	destType.equals(other.destType));
	}

	public abstract GraphicsPrimitive makePrimitive(SurfaceType srctype,
	CompositeType comptype,
	SurfaceType dsttype);

	public abstract GraphicsPrimitive traceWrap();

	static HashMap traceMap;

	public static int traceflags;
	public static String tracefile;
	public static PrintStream traceout;

	public static final int TRACELOG = 1;
	public static final int TRACETIMESTAMP = 2;
	public static final int TRACECOUNTS = 4;

	static {
	GetPropertyAction gpa = new GetPropertyAction("sun.java2d.trace");
	String trace = AccessController.doPrivileged(gpa);
	if (trace != null) {
	boolean verbose = false;
	int traceflags = 0;
	StringTokenizer st = new StringTokenizer(trace, ",");
	while (st.hasMoreTokens()) {
	String tok = st.nextToken();
	if (tok.equalsIgnoreCase("count")) {
	traceflags \|= GraphicsPrimitive.TRACECOUNTS;
	} else if (tok.equalsIgnoreCase("log")) {
	traceflags \|= GraphicsPrimitive.TRACELOG;
	} else if (tok.equalsIgnoreCase("timestamp")) {
	traceflags \|= GraphicsPrimitive.TRACETIMESTAMP;
	} else if (tok.equalsIgnoreCase("verbose")) {
	verbose = true;
	} else if (tok.regionMatches(true, 0, "out:", 0, 4)) {
	tracefile = tok.substring(4);
	} else {
	if (!tok.equalsIgnoreCase("help")) {
	System.err.println("unrecognized token: "+tok);
	}
	System.err.println("usage: -Dsun.java2d.trace="+
	"[log[,timestamp]],[count],"+
	"[out:<filename>],[help],[verbose]");
	}
	}
	if (verbose) {
	System.err.print("GraphicsPrimitive logging ");
	if ((traceflags & GraphicsPrimitive.TRACELOG) != 0) {
	System.err.println("enabled");
	System.err.print("GraphicsPrimitive timetamps ");
	if ((traceflags & GraphicsPrimitive.TRACETIMESTAMP) != 0) {
	System.err.println("enabled");
	} else {
	System.err.println("disabled");
	}
	} else {
	System.err.println("[and timestamps] disabled");
	}
	System.err.print("GraphicsPrimitive invocation counts ");
	if ((traceflags & GraphicsPrimitive.TRACECOUNTS) != 0) {
	System.err.println("enabled");
	} else {
	System.err.println("disabled");
	}
	System.err.print("GraphicsPrimitive trace output to ");
	if (tracefile == null) {
	System.err.println("System.err");
	} else {
	System.err.println("file '"+tracefile+"'");
	}
	}
	GraphicsPrimitive.traceflags = traceflags;
	}
	}

	public static boolean tracingEnabled() {
	return (traceflags != 0);
	}

	private static PrintStream getTraceOutputFile() {
	if (traceout == null) {
	if (tracefile != null) {
	FileOutputStream o = AccessController.doPrivileged(
	new PrivilegedAction<FileOutputStream>() {
	public FileOutputStream run() {
	try {
	return new FileOutputStream(tracefile);
	} catch (FileNotFoundException e) {
	return null;
	}
	}
	});
	if (o != null) {
	traceout = new PrintStream(o);
	} else {
	traceout = System.err;
	}
	} else {
	traceout = System.err;
	}
	}
	return traceout;
	}

	public static class TraceReporter extends Thread {
	public static void setShutdownHook() {
	AccessController.doPrivileged(new PrivilegedAction<Void>() {
	public Void run() {
	TraceReporter t = new TraceReporter();
	t.setContextClassLoader(null);
	Runtime.getRuntime().addShutdownHook(t);
	return null;
	}
	});
	}

	public void run() {
	PrintStream ps = getTraceOutputFile();
	Iterator iterator = traceMap.entrySet().iterator();
	long total = 0;
	int numprims = 0;
	while (iterator.hasNext()) {
	Map.Entry me = (Map.Entry) iterator.next();
	Object prim = me.getKey();
	int[] count = (int[]) me.getValue();
	if (count[0] == 1) {
	ps.print("1 call to ");
	} else {
	ps.print(count[0]+" calls to ");
	}
	ps.println(prim);
	numprims++;
	total += count[0];
	}
	if (numprims == 0) {
	ps.println("No graphics primitives executed");
	} else if (numprims > 1) {
	ps.println(total+" total calls to "+
	numprims+" different primitives");
	}
	}
	}

	public synchronized static void tracePrimitive(Object prim) {
	if ((traceflags & TRACECOUNTS) != 0) {
	if (traceMap == null) {
	traceMap = new HashMap();
	TraceReporter.setShutdownHook();
	}
	Object o = traceMap.get(prim);
	if (o == null) {
	o = new int[1];
	traceMap.put(prim, o);
	}
	((int[]) o)[0]++;
	}
	if ((traceflags & TRACELOG) != 0) {
	PrintStream ps = getTraceOutputFile();
	if ((traceflags & TRACETIMESTAMP) != 0) {
	ps.print(System.currentTimeMillis()+": ");
	}
	ps.println(prim);
	}
	}

	protected void setupGeneralBinaryOp(GeneralBinaryOp gbo) {
	int primID = gbo.getPrimTypeID();
	String methodSignature = gbo.getSignature();
	SurfaceType srctype = gbo.getSourceType();
	CompositeType comptype = gbo.getCompositeType();
	SurfaceType dsttype = gbo.getDestType();
	Blit convertsrc, convertdst, convertres;
	GraphicsPrimitive performop;

	convertsrc = createConverter(srctype, SurfaceType.IntArgb);
	performop = GraphicsPrimitiveMgr.locatePrim(primID,
	SurfaceType.IntArgb,
	comptype, dsttype);
	if (performop != null) {
	convertdst = null;
	convertres = null;
	} else {
	performop = getGeneralOp(primID, comptype);
	if (performop == null) {
	throw new InternalError("Cannot construct general op for "+
	methodSignature+" "+comptype);
	}
	convertdst = createConverter(dsttype, SurfaceType.IntArgb);
	convertres = createConverter(SurfaceType.IntArgb, dsttype);
	}

	gbo.setPrimitives(convertsrc, convertdst, performop, convertres);
	}

	protected void setupGeneralUnaryOp(GeneralUnaryOp guo) {
	int primID = guo.getPrimTypeID();
	String methodSignature = guo.getSignature();
	CompositeType comptype = guo.getCompositeType();
	SurfaceType dsttype = guo.getDestType();

	Blit convertdst = createConverter(dsttype, SurfaceType.IntArgb);
	GraphicsPrimitive performop = getGeneralOp(primID, comptype);
	Blit convertres = createConverter(SurfaceType.IntArgb, dsttype);
	if (convertdst == null \|\| performop == null \|\| convertres == null) {
	throw new InternalError("Cannot construct binary op for "+
	comptype+" "+dsttype);
	}

	guo.setPrimitives(convertdst, performop, convertres);
	}

	protected static Blit createConverter(SurfaceType srctype,
	SurfaceType dsttype)
	{
	if (srctype.equals(dsttype)) {
	return null;
	}
	Blit cv = Blit.getFromCache(srctype, CompositeType.SrcNoEa, dsttype);
	if (cv == null) {
	throw new InternalError("Cannot construct converter for "+
	srctype+"=>"+dsttype);
	}
	return cv;
	}

	protected static SurfaceData convertFrom(Blit ob, SurfaceData srcData,
	int srcX, int srcY, int w, int h,
	SurfaceData dstData)
	{
	return convertFrom(ob, srcData,
	srcX, srcY, w, h, dstData,
	BufferedImage.TYPE_INT_ARGB);
	}

	protected static SurfaceData convertFrom(Blit ob, SurfaceData srcData,
	int srcX, int srcY, int w, int h,
	SurfaceData dstData, int type)
	{
	if (dstData != null) {
	Rectangle r = dstData.getBounds();
	if (w > r.width \|\| h > r.height) {
	dstData = null;
	}
	}
	if (dstData == null) {
	BufferedImage dstBI = new BufferedImage(w, h, type);
	dstData = BufImgSurfaceData.createData(dstBI);
	}
	ob.Blit(srcData, dstData, AlphaComposite.Src, null,
	srcX, srcY, 0, 0, w, h);
	return dstData;
	}

	protected static void convertTo(Blit ob,
	SurfaceData srcImg, SurfaceData dstImg,
	Region clip,
	int dstX, int dstY, int w, int h)
	{
	if (ob != null) {
	ob.Blit(srcImg, dstImg, AlphaComposite.Src, clip,
	0, 0, dstX, dstY, w, h);
	}
	}

	protected static GraphicsPrimitive getGeneralOp(int primID,
	CompositeType comptype)
	{
	return GraphicsPrimitiveMgr.locatePrim(primID,
	SurfaceType.IntArgb,
	comptype,
	SurfaceType.IntArgb);
	}

	public static String simplename(Field[] fields, Object o) {
	for (int i = 0; i < fields.length; i++) {
	Field f = fields[i];
	try {
	if (o == f.get(null)) {
	return f.getName();
	}
	} catch (Exception e) {
	}
	}
	return "\""+o.toString()+"\"";
	}

	public static String simplename(SurfaceType st) {
	return simplename(SurfaceType.class.getDeclaredFields(), st);
	}

	public static String simplename(CompositeType ct) {
	return simplename(CompositeType.class.getDeclaredFields(), ct);
	}

	private String cachedname;

	public String toString() {
	if (cachedname == null) {
	String sig = methodSignature;
	int index = sig.indexOf('(');
	if (index >= 0) {
	sig = sig.substring(0, index);
	}
	cachedname = (getClass().getName()+"::"+
	sig+"("+
	simplename(sourceType)+", "+
	simplename(compositeType)+", "+
	simplename(destType)+")");
	}
	return cachedname;
	}
	}

Back to index...