1 /*
   2  * Copyright (c) 2005, 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.pipe;
  27 
  28 import java.awt.AlphaComposite;
  29 import java.awt.Color;
  30 import java.awt.Composite;
  31 import java.awt.Paint;
  32 import java.awt.geom.AffineTransform;
  33 import sun.java2d.pipe.hw.AccelSurface;
  34 import sun.java2d.InvalidPipeException;
  35 import sun.java2d.SunGraphics2D;
  36 import sun.java2d.loops.XORComposite;
  37 import static sun.java2d.pipe.BufferedOpCodes.*;
  38 import static sun.java2d.pipe.BufferedRenderPipe.BYTES_PER_SPAN;
  39 
  40 import javax.tools.annotation.GenerateNativeHeader;
  41 
  42 /**
  43  * Base context class for managing state in a single-threaded rendering
  44  * environment.  Each state-setting operation (e.g. SET_COLOR) is added to
  45  * the provided RenderQueue, which will be processed at a later time by a
  46  * single thread.  Note that the RenderQueue lock must be acquired before
  47  * calling the validate() method (or any other method in this class).  See
  48  * the RenderQueue class comments for a sample usage scenario.
  49  *
  50  * @see RenderQueue
  51  */
  52 /* No native methods here, but the constants are needed in the supporting JNI code */
  53 @GenerateNativeHeader
  54 public abstract class BufferedContext {
  55 
  56     /*
  57      * The following flags help the internals of validate() determine
  58      * the appropriate (meaning correct, or optimal) code path when
  59      * setting up the current context.  The flags can be bitwise OR'd
  60      * together as needed.
  61      */
  62 
  63     /**
  64      * Indicates that no flags are needed; take all default code paths.
  65      */
  66     public static final int NO_CONTEXT_FLAGS = (0 << 0);
  67     /**
  68      * Indicates that the source surface (or color value, if it is a simple
  69      * rendering operation) is opaque (has an alpha value of 1.0).  If this
  70      * flag is present, it allows us to disable blending in certain
  71      * situations in order to improve performance.
  72      */
  73     public static final int SRC_IS_OPAQUE    = (1 << 0);
  74     /**
  75      * Indicates that the operation uses an alpha mask, which may determine
  76      * the code path that is used when setting up the current paint state.
  77      */
  78     public static final int USE_MASK         = (1 << 1);
  79 
  80     protected RenderQueue rq;
  81     protected RenderBuffer buf;
  82 
  83     /**
  84      * This is a reference to the most recently validated BufferedContext.  If
  85      * this value is null, it means that there is no current context.  It is
  86      * provided here so that validate() only needs to do a quick reference
  87      * check to see if the BufferedContext passed to that method is the same
  88      * as the one we've cached here.
  89      */
  90     protected static BufferedContext currentContext;
  91 
  92     private AccelSurface    validatedSrcData;
  93     private AccelSurface    validatedDstData;
  94     private Region          validatedClip;
  95     private Composite       validatedComp;
  96     private Paint           validatedPaint;
  97     // renamed from isValidatedPaintAColor as part of a work around for 6764257
  98     private boolean         isValidatedPaintJustAColor;
  99     private int             validatedRGB;
 100     private int             validatedFlags;
 101     private boolean         xformInUse;
 102     private AffineTransform transform;
 103 
 104     protected BufferedContext(RenderQueue rq) {
 105         this.rq = rq;
 106         this.buf = rq.getBuffer();
 107     }
 108 
 109     /**
 110      * Fetches the BufferedContextContext associated with the dst. surface
 111      * and validates the context using the given parameters.  Most rendering
 112      * operations will call this method first in order to set the necessary
 113      * state before issuing rendering commands.
 114      *
 115      * Note: must be called while the RenderQueue lock is held.
 116      *
 117      * It's assumed that the type of surfaces has been checked by the Renderer
 118      *
 119      * @throws InvalidPipeException if either src or dest surface is not valid
 120      * or lost
 121      * @see RenderQueue#lock
 122      * @see RenderQueue#unlock
 123      */
 124     public static void validateContext(AccelSurface srcData,
 125                                        AccelSurface dstData,
 126                                        Region clip, Composite comp,
 127                                        AffineTransform xform,
 128                                        Paint paint, SunGraphics2D sg2d,
 129                                        int flags)
 130     {
 131         // assert rq.lock.isHeldByCurrentThread();
 132         BufferedContext d3dc = dstData.getContext();
 133         d3dc.validate(srcData, dstData,
 134                       clip, comp, xform, paint, sg2d, flags);
 135     }
 136 
 137     /**
 138      * Fetches the BufferedContextassociated with the surface
 139      * and disables all context state settings.
 140      *
 141      * Note: must be called while the RenderQueue lock is held.
 142      *
 143      * It's assumed that the type of surfaces has been checked by the Renderer
 144      *
 145      * @throws InvalidPipeException if the surface is not valid
 146      * or lost
 147      * @see RenderQueue#lock
 148      * @see RenderQueue#unlock
 149      */
 150     public static void validateContext(AccelSurface surface) {
 151         // assert rt.lock.isHeldByCurrentThread();
 152         validateContext(surface, surface,
 153                         null, null, null, null, null, NO_CONTEXT_FLAGS);
 154     }
 155 
 156     /**
 157      * Validates the given parameters against the current state for this
 158      * context.  If this context is not current, it will be made current
 159      * for the given source and destination surfaces, and the viewport will
 160      * be updated.  Then each part of the context state (clip, composite,
 161      * etc.) is checked against the previous value.  If the value has changed
 162      * since the last call to validate(), it will be updated accordingly.
 163      *
 164      * Note that the SunGraphics2D parameter is only used for the purposes
 165      * of validating a (non-null) Paint parameter.  In all other cases it
 166      * is safe to pass a null SunGraphics2D and it will be ignored.
 167      *
 168      * Note: must be called while the RenderQueue lock is held.
 169      *
 170      * It's assumed that the type of surfaces has been checked by the Renderer
 171      *
 172      * @throws InvalidPipeException if either src or dest surface is not valid
 173      * or lost
 174      */
 175     public void validate(AccelSurface srcData, AccelSurface dstData,
 176                          Region clip, Composite comp,
 177                          AffineTransform xform,
 178                          Paint paint, SunGraphics2D sg2d, int flags)
 179     {
 180         // assert rq.lock.isHeldByCurrentThread();
 181 
 182         boolean updateClip = false;
 183         boolean updatePaint = false;
 184 
 185         if (!dstData.isValid() ||
 186             dstData.isSurfaceLost() || srcData.isSurfaceLost())
 187         {
 188             invalidateContext();
 189             throw new InvalidPipeException("bounds changed or surface lost");
 190         }
 191 
 192         if (paint instanceof Color) {
 193             // REMIND: not 30-bit friendly
 194             int newRGB = ((Color)paint).getRGB();
 195             if (isValidatedPaintJustAColor) {
 196                 if (newRGB != validatedRGB) {
 197                     validatedRGB = newRGB;
 198                     updatePaint = true;
 199                 }
 200             } else {
 201                 validatedRGB = newRGB;
 202                 updatePaint = true;
 203                 isValidatedPaintJustAColor = true;
 204             }
 205         } else if (validatedPaint != paint) {
 206             updatePaint = true;
 207             // this should be set when we are switching from paint to color
 208             // in which case this condition will be true
 209             isValidatedPaintJustAColor = false;
 210         }
 211 
 212         if ((currentContext != this) ||
 213             (srcData != validatedSrcData) ||
 214             (dstData != validatedDstData))
 215         {
 216             if (dstData != validatedDstData) {
 217                 // the clip is dependent on the destination surface, so we
 218                 // need to update it if we have a new destination surface
 219                 updateClip = true;
 220             }
 221 
 222             if (paint == null) {
 223                 // make sure we update the color state (otherwise, it might
 224                 // not be updated if this is the first time the context
 225                 // is being validated)
 226                 updatePaint = true;
 227             }
 228 
 229             // update the current source and destination surfaces
 230             setSurfaces(srcData, dstData);
 231 
 232             currentContext = this;
 233             validatedSrcData = srcData;
 234             validatedDstData = dstData;
 235         }
 236 
 237         // validate clip
 238         if ((clip != validatedClip) || updateClip) {
 239             if (clip != null) {
 240                 if (updateClip ||
 241                     validatedClip == null ||
 242                     !(validatedClip.isRectangular() && clip.isRectangular()) ||
 243                     ((clip.getLoX() != validatedClip.getLoX() ||
 244                       clip.getLoY() != validatedClip.getLoY() ||
 245                       clip.getHiX() != validatedClip.getHiX() ||
 246                       clip.getHiY() != validatedClip.getHiY())))
 247                 {
 248                     setClip(clip);
 249                 }
 250             } else {
 251                 resetClip();
 252             }
 253             validatedClip = clip;
 254         }
 255 
 256         // validate composite (note that a change in the context flags
 257         // may require us to update the composite state, even if the
 258         // composite has not changed)
 259         if ((comp != validatedComp) || (flags != validatedFlags)) {
 260             if (comp != null) {
 261                 setComposite(comp, flags);
 262             } else {
 263                 resetComposite();
 264             }
 265             // the paint state is dependent on the composite state, so make
 266             // sure we update the color below
 267             updatePaint = true;
 268             validatedComp = comp;
 269             validatedFlags = flags;
 270         }
 271 
 272         // validate transform
 273         boolean txChanged = false;
 274         if (xform == null) {
 275             if (xformInUse) {
 276                 resetTransform();
 277                 xformInUse = false;
 278                 txChanged = true;
 279             } else if (sg2d != null && !sg2d.transform.equals(transform)) {
 280                 txChanged = true;
 281             }
 282             if (sg2d != null && txChanged) {
 283                 transform = new AffineTransform(sg2d.transform);
 284             }
 285         } else {
 286             setTransform(xform);
 287             xformInUse = true;
 288             txChanged = true;
 289         }
 290         // non-Color paints may require paint revalidation
 291         if (!isValidatedPaintJustAColor && txChanged) {
 292             updatePaint = true;
 293         }
 294 
 295         // validate paint
 296         if (updatePaint) {
 297             if (paint != null) {
 298                 BufferedPaints.setPaint(rq, sg2d, paint, flags);
 299             } else {
 300                 BufferedPaints.resetPaint(rq);
 301             }
 302             validatedPaint = paint;
 303         }
 304 
 305         // mark dstData dirty
 306         // REMIND: is this really needed now? we do it in SunGraphics2D..
 307         dstData.markDirty();
 308     }
 309 
 310     /**
 311      * Invalidates the surfaces associated with this context.  This is
 312      * useful when the context is no longer needed, and we want to break
 313      * the chain caused by these surface references.
 314      *
 315      * Note: must be called while the RenderQueue lock is held.
 316      *
 317      * @see RenderQueue#lock
 318      * @see RenderQueue#unlock
 319      */
 320     public void invalidateSurfaces() {
 321         validatedSrcData = null;
 322         validatedDstData = null;
 323     }
 324 
 325     private void setSurfaces(AccelSurface srcData,
 326                              AccelSurface dstData)
 327     {
 328         // assert rq.lock.isHeldByCurrentThread();
 329         rq.ensureCapacityAndAlignment(20, 4);
 330         buf.putInt(SET_SURFACES);
 331         buf.putLong(srcData.getNativeOps());
 332         buf.putLong(dstData.getNativeOps());
 333     }
 334 
 335     private void resetClip() {
 336         // assert rq.lock.isHeldByCurrentThread();
 337         rq.ensureCapacity(4);
 338         buf.putInt(RESET_CLIP);
 339     }
 340 
 341     private void setClip(Region clip) {
 342         // assert rq.lock.isHeldByCurrentThread();
 343         if (clip.isRectangular()) {
 344             rq.ensureCapacity(20);
 345             buf.putInt(SET_RECT_CLIP);
 346             buf.putInt(clip.getLoX()).putInt(clip.getLoY());
 347             buf.putInt(clip.getHiX()).putInt(clip.getHiY());
 348         } else {
 349             rq.ensureCapacity(28); // so that we have room for at least a span
 350             buf.putInt(BEGIN_SHAPE_CLIP);
 351             buf.putInt(SET_SHAPE_CLIP_SPANS);
 352             // include a placeholder for the span count
 353             int countIndex = buf.position();
 354             buf.putInt(0);
 355             int spanCount = 0;
 356             int remainingSpans = buf.remaining() / BYTES_PER_SPAN;
 357             int span[] = new int[4];
 358             SpanIterator si = clip.getSpanIterator();
 359             while (si.nextSpan(span)) {
 360                 if (remainingSpans == 0) {
 361                     buf.putInt(countIndex, spanCount);
 362                     rq.flushNow();
 363                     buf.putInt(SET_SHAPE_CLIP_SPANS);
 364                     countIndex = buf.position();
 365                     buf.putInt(0);
 366                     spanCount = 0;
 367                     remainingSpans = buf.remaining() / BYTES_PER_SPAN;
 368                 }
 369                 buf.putInt(span[0]); // x1
 370                 buf.putInt(span[1]); // y1
 371                 buf.putInt(span[2]); // x2
 372                 buf.putInt(span[3]); // y2
 373                 spanCount++;
 374                 remainingSpans--;
 375             }
 376             buf.putInt(countIndex, spanCount);
 377             rq.ensureCapacity(4);
 378             buf.putInt(END_SHAPE_CLIP);
 379         }
 380     }
 381 
 382     private void resetComposite() {
 383         // assert rq.lock.isHeldByCurrentThread();
 384         rq.ensureCapacity(4);
 385         buf.putInt(RESET_COMPOSITE);
 386     }
 387 
 388     private void setComposite(Composite comp, int flags) {
 389         // assert rq.lock.isHeldByCurrentThread();
 390         if (comp instanceof AlphaComposite) {
 391             AlphaComposite ac = (AlphaComposite)comp;
 392             rq.ensureCapacity(16);
 393             buf.putInt(SET_ALPHA_COMPOSITE);
 394             buf.putInt(ac.getRule());
 395             buf.putFloat(ac.getAlpha());
 396             buf.putInt(flags);
 397         } else if (comp instanceof XORComposite) {
 398             int xorPixel = ((XORComposite)comp).getXorPixel();
 399             rq.ensureCapacity(8);
 400             buf.putInt(SET_XOR_COMPOSITE);
 401             buf.putInt(xorPixel);
 402         } else {
 403             throw new InternalError("not yet implemented");
 404         }
 405     }
 406 
 407     private void resetTransform() {
 408         // assert rq.lock.isHeldByCurrentThread();
 409         rq.ensureCapacity(4);
 410         buf.putInt(RESET_TRANSFORM);
 411     }
 412 
 413     private void setTransform(AffineTransform xform) {
 414         // assert rq.lock.isHeldByCurrentThread();
 415         rq.ensureCapacityAndAlignment(52, 4);
 416         buf.putInt(SET_TRANSFORM);
 417         buf.putDouble(xform.getScaleX());
 418         buf.putDouble(xform.getShearY());
 419         buf.putDouble(xform.getShearX());
 420         buf.putDouble(xform.getScaleY());
 421         buf.putDouble(xform.getTranslateX());
 422         buf.putDouble(xform.getTranslateY());
 423     }
 424 
 425     /**
 426      * Resets this context's surfaces and all attributes.
 427      *
 428      * Note: must be called while the RenderQueue lock is held.
 429      *
 430      * @see RenderQueue#lock
 431      * @see RenderQueue#unlock
 432      */
 433     public void invalidateContext() {
 434         resetTransform();
 435         resetComposite();
 436         resetClip();
 437         BufferedPaints.resetPaint(rq);
 438         invalidateSurfaces();
 439         validatedComp = null;
 440         validatedClip = null;
 441         validatedPaint = null;
 442         isValidatedPaintJustAColor = false;
 443         xformInUse = false;
 444     }
 445 
 446     /**
 447      * Returns a singleton {@code RenderQueue} object used by the rendering
 448      * pipeline.
 449      *
 450      * @return a render queue
 451      * @see RenderQueue
 452      */
 453     public abstract RenderQueue getRenderQueue();
 454 
 455     /**
 456      * Saves the the state of this context.
 457      * It may reset the current context.
 458      *
 459      * Note: must be called while the RenderQueue lock is held.
 460      *
 461      * @see RenderQueue#lock
 462      * @see RenderQueue#unlock
 463      */
 464     public abstract void saveState();
 465 
 466     /**
 467      * Restores the native state of this context.
 468      * It may reset the current context.
 469      *
 470      * Note: must be called while the RenderQueue lock is held.
 471      *
 472      * @see RenderQueue#lock
 473      * @see RenderQueue#unlock
 474      */
 475     public abstract void restoreState();
 476 }