libjava/classpath/gnu/java/awt/java2d/AlphaCompositeContext.java

   1 /* AlphaCompositeContext.java -- CompositeContext impl for AlphaComposite
   2    Copyright (C) 2006 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package gnu.java.awt.java2d;
  40
  41 import java.awt.AWTError;
  42 import java.awt.AlphaComposite;
  43 import java.awt.CompositeContext;
  44 import java.awt.image.ColorModel;
  45 import java.awt.image.Raster;
  46 import java.awt.image.WritableRaster;
  47
  48 /**
  49  * A CompositeContext implementation for {@link AlphaComposite}.
  50  *
  51  * @author Roman Kennke (kennke@aicas.com)
  52  */
  53 public class AlphaCompositeContext
  54   implements CompositeContext
  55 {
  56
  57   /**
  58    * The Composite object for which we perform compositing.
  59    */
  60   private AlphaComposite composite;
  61
  62   /**
  63    * The source color model.
  64    */
  65   private ColorModel srcColorModel;
  66
  67   /**
  68    * The destination color model.
  69    */
  70   private ColorModel dstColorModel;
  71
  72   /**
  73    * The blending factor for the source.
  74    */
  75   private float fs;
  76
  77   /**
  78    * The blending factor for the destination.
  79    */
  80   private float fd;
  81
  82   /**
  83    * Creates a new AlphaCompositeContext.
  84    *
  85    * @param aComp the AlphaComposite object
  86    * @param srcCM the source color model
  87    * @param dstCM the destination color model
  88    */
  89   public AlphaCompositeContext(AlphaComposite aComp, ColorModel srcCM,
  90                                ColorModel dstCM)
  91   {
  92     composite = aComp;
  93     srcColorModel = srcCM;
  94     dstColorModel = dstCM;
  95
  96
  97     // Determine the blending factors according to the rule in the
  98     // AlphaComposite. For some rules the factors must be determined
  99     // dynamically because they depend on the actual pixel value.
 100     switch (composite.getRule())
 101     {
 102       case AlphaComposite.CLEAR:
 103         fs = 0.F;
 104         fd= 0.F;
 105         break;
 106       case AlphaComposite.DST:
 107         fs = 0.F;
 108         fd= 1.F;
 109         break;
 110       case AlphaComposite.DST_ATOP:
 111         fs = 1.F; // Determined later as 1 - alpha_dst;
 112         fd = 1.F; // Determined later as alpha_src;
 113         break;
 114       case AlphaComposite.DST_IN:
 115         fs = 0.F;
 116         fd = 0.F; // Determined later as alpha_src;
 117         break;
 118       case AlphaComposite.DST_OUT:
 119         fs = 0.F;
 120         fd = 0.F; // Determined later as 1 - alpha_src;
 121         break;
 122       case AlphaComposite.DST_OVER:
 123         fs = 1.F; // Determined later as 1 - alpha_dst.
 124         fd= 1.F;
 125         break;
 126       case AlphaComposite.SRC:
 127         fs = 1.F;
 128         fd= 0.F;
 129         break;
 130       case AlphaComposite.SRC_ATOP:
 131         fs = 1.F; // Determined later as alpha_dst;
 132         fd = 1.F; // Determined later as 1 - alpha_src;
 133         break;
 134       case AlphaComposite.SRC_IN:
 135         fs = 0.F; // Determined later as alpha_dst;
 136         fd = 0.F;
 137         break;
 138       case AlphaComposite.SRC_OUT:
 139         fs = 0.F; // Determined later as 1 - alpha_dst;
 140         fd = 0.F;
 141         break;
 142       case AlphaComposite.SRC_OVER:
 143         fs = 1.F;
 144         fd= 1.F; // Determined later as 1 - alpha_src.
 145         break;
 146       case AlphaComposite.XOR:
 147         fs = 1.F; // Determined later as 1 - alpha_dst.
 148         fd= 1.F; // Determined later as 1 - alpha_src.
 149         break;
 150       default:
 151         throw new AWTError("Illegal AlphaComposite rule");
 152     }
 153
 154   }
 155
 156   /**
 157    * Releases all resources held by this composite object.
 158    */
 159   public void dispose()
 160   {
 161     // Nothing to do here yet.
 162   }
 163
 164   /**
 165    * Performs compositing according to the rules specified in the
 166    * AlphaComposite from the constructor.
 167    */
 168   public void compose(Raster src, Raster dstIn, WritableRaster dstOut)
 169   {
 170
 171     // TODO: This implementation is very general and highly inefficient. There
 172     // are two possible ways to optimize this:
 173     // 1. Special cased implementations for common ColorModels and transfer
 174     //    types.
 175     // 2. Native implementation.
 176
 177     int x0 = src.getMinX();
 178     int y0 = src.getMinY();
 179     int width = src.getWidth();
 180     int height = src.getHeight();
 181     int x1 = x0 + width;
 182     int y1 = y0 + height;
 183
 184     Object srcPixel = null;
 185     Object dstPixel = null;
 186
 187     // Prepare the array that holds the color and alpha components of the
 188     // source pixels.
 189     float[] srcComponents;
 190     int srcComponentsLength = srcColorModel.getNumComponents();
 191     if (! srcColorModel.hasAlpha())
 192       srcComponentsLength += 1;
 193     srcComponents = new float[srcComponentsLength];
 194
 195     // Prepare the array that holds the color and alpha components of the
 196     // destination pixels.
 197     float[] dstComponents;
 198     int dstComponentsLength = dstColorModel.getNumComponents();
 199     if (! dstColorModel.hasAlpha())
 200       dstComponentsLength += 1;
 201     dstComponents = new float[dstComponentsLength];
 202
 203     if (srcComponentsLength != dstComponentsLength)
 204       throw new AWTError("The color models of the source and destination have"
 205                          + "incompatible number of color components");
 206
 207     int srcTransferType = srcColorModel.getTransferType();
 208     int dstTransferType = dstColorModel.getTransferType();
 209
 210     for (int y = y0; y < y1; y++)
 211       {
 212         for (int x = x0; x < x1; x++)
 213           {
 214             // Fetch source pixel.
 215             srcPixel = src.getDataElements(x, y, (int[]) srcPixel);
 216             // Fetch destination pixel.
 217             dstPixel = dstIn.getDataElements(x, y, dstPixel);
 218             // Get normalized components. This is the only type that is
 219             // guaranteed to be supported by all ColorModels.
 220             srcComponents =
 221               srcColorModel.getNormalizedComponents(srcPixel, srcComponents, 0);
 222             if (! srcColorModel.hasAlpha())
 223               srcComponents[srcComponentsLength - 1] = 1.0F;
 224             dstComponents =
 225               dstColorModel.getNormalizedComponents(dstPixel, dstComponents, 0);
 226             if (! dstColorModel.hasAlpha())
 227               dstComponents[dstComponentsLength - 1] = 1.0F;
 228
 229             // Prepare the input.
 230             float compositeAlpha = composite.getAlpha();
 231             srcComponents[srcComponentsLength - 1] *= compositeAlpha;
 232             if (srcColorModel.isAlphaPremultiplied())
 233               {
 234                 for (int i = srcComponentsLength - 2; i >= 0; i--)
 235                   srcComponents[i] *= compositeAlpha;
 236               }
 237             else
 238               {
 239                 for (int i = srcComponentsLength - 1; i >= 0; i--)
 240                   srcComponents[i] *= srcComponents[srcComponentsLength - 1];
 241               }
 242             if (! dstColorModel.isAlphaPremultiplied())
 243               {
 244                 for (int i = dstComponentsLength - 2; i >= 0; i--)
 245                   dstComponents[i] *= dstComponents[dstComponents.length - 1];
 246               }
 247
 248             // Determine the blending factors according to the rule in the
 249             // AlphaComposite. For some rules the factors must be determined
 250             // dynamically because they depend on the actual pixel value.
 251             float srcAlpha = srcComponents[srcComponentsLength - 1];
 252             float dstAlpha = dstComponents[dstComponentsLength - 1];
 253             switch (composite.getRule())
 254             {
 255               case AlphaComposite.DST_ATOP:
 256                 fs = 1.F - dstAlpha;
 257                 fd = srcAlpha;
 258                 break;
 259               case AlphaComposite.DST_IN:
 260                 fd = srcAlpha;
 261                 break;
 262               case AlphaComposite.DST_OUT:
 263                 fd = 1.F - srcAlpha;
 264                 break;
 265               case AlphaComposite.DST_OVER:
 266                 fs = 1.F - dstAlpha;
 267                 break;
 268               case AlphaComposite.SRC_ATOP:
 269                 fs = srcAlpha;
 270                 fd = 1.F - srcAlpha;
 271                 break;
 272               case AlphaComposite.SRC_IN:
 273                 fs = dstAlpha;
 274                 break;
 275               case AlphaComposite.SRC_OUT:
 276                 fs = 1.F - dstAlpha;
 277                 break;
 278               case AlphaComposite.SRC_OVER:
 279                 fd= 1.F - srcAlpha;
 280                 break;
 281               case AlphaComposite.XOR:
 282                 fs = 1.F - dstAlpha;
 283                 fd= 1.F - srcAlpha;
 284                 break;
 285               default:
 286                 // For the other cases the factors have already been determined
 287                 // in the constructor.
 288             }
 289
 290             // Apply the blending equation to the pixels.
 291             for (int i = 0; i < srcComponentsLength; i++)
 292               {
 293                 dstComponents[i] = srcComponents[i] * fs
 294                                    + dstComponents[i] * fd;
 295               }
 296
 297             // Convert the result back when the destination is not
 298             // alpha-premultiplied.
 299             dstAlpha = dstComponents[dstComponentsLength - 1];
 300             if (!dstColorModel.isAlphaPremultiplied() && dstAlpha != 0.F)
 301               {
 302                 for (int i = 0; i < dstComponentsLength - 1; i++)
 303                   {
 304                     dstComponents[i] = dstComponents[i] / dstAlpha;
 305                   }
 306               }
 307
 308             // Store the result in the destination raster.
 309             dstPixel = dstColorModel.getDataElements(dstComponents, 0,
 310                                                      dstPixel);
 311             dstOut.setDataElements(x, y, dstPixel);
 312           } // End X loop.
 313       } // End Y loop.
 314   }
 315
 316 }