text: /*
   * Copyright (c) 2000, 2002, 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.awt.image;
  import java.awt.image.ColorModel;
  import java.awt.image.DataBuffer;
  
  /**
   * This class provides utilities for converting between the standard
   * rgb colorspace specification and the equivalent value for a pixel
   * of a given surface type.  The class was designed for use by the
   * SurfaceType objects, since the conversion between pixel values
   * and rgb values is inherently tied to the type of surface we are
   * dealing with.  Some conversions cannot be done automatically,
   * however (for example, the AnyInt or AnyDCM surface types), so
   * we require the caller to pass in a ColorModel object so that
   * we can calculate the pixel values in these generic cases as well.
   */
  public class PixelConverter {
  
      /**
       * Default object, used as a fallback for any surface types where
       * we do not know enough about the surface to calculate the
       * conversions directly.  We use the ColorModel object to assist
       * us in these cases.
       */
      public static final PixelConverter instance = new PixelConverter();
  
  
      protected int alphaMask = 0;
  
      protected PixelConverter() {}
  
      public int rgbToPixel(int rgb, ColorModel cm) {
          Object obj = cm.getDataElements(rgb, null);
          switch (cm.getTransferType()) {
          case DataBuffer.TYPE_BYTE:
              byte[] bytearr = (byte[]) obj;
              int pix = 0;
  
              switch(bytearr.length) {
              default: // bytearr.length >= 4
                  pix = bytearr[3] << 24;
                  // FALLSTHROUGH
              case 3:
                  pix |= (bytearr[2] & 0xff) << 16;
                  // FALLSTHROUGH
              case 2:
                  pix |= (bytearr[1] & 0xff) << 8;
                  // FALLSTHROUGH
              case 1:
                  pix |= (bytearr[0] & 0xff);
              }
  
              return pix;
          case DataBuffer.TYPE_SHORT:
          case DataBuffer.TYPE_USHORT:
              short[] shortarr = (short[]) obj;
  
              return (((shortarr.length > 1) ? shortarr[1] << 16 : 0) |
                      shortarr[0] & 0xffff);
          case DataBuffer.TYPE_INT:
              return ((int[]) obj)[0];
          default:
              return rgb;
          }
      }
  
      public int pixelToRgb(int pixel, ColorModel cm) {
          // REMIND: Not yet implemented
          return pixel;
      }
  
      public final int getAlphaMask() {
          return alphaMask;
      }
  
  
      /**
       * Subclasses of PixelConverter.  These subclasses are
       * specific to surface types where we can definitively
       * calculate the conversions.  Note that some conversions
       * are lossy; that is, we cannot necessarily convert a
       * value and then convert it back and wind up with the
       * original value.  For example, an rgb value  that has
       * an alpha != 1 cannot be converted to an Xrgb pixel
       * without losing the information in the alpha component.
       *
       * The conversion strategies associated with the ThreeByte*
       * and FourByte* surface types swap the components around
       * due to the ordering used when the bytes are stored.  The
       * low order byte of a packed-byte pixel will be the first
       * byte stored and the high order byte will be the last byte
       * stored.  For example, the ThreeByteBgr surface type is
       * associated with an Xrgb conversion object because the
       * three bytes are stored as follows:
       *   pixels[0] = b;    // low order byte of an Xrgb pixel
       *   pixels[1] = g;
       *   pixels[2] = r;    // high order byte of an Xrgb pixel
       */
  
      public static class Rgbx extends PixelConverter {
          public static final PixelConverter instance = new Rgbx();
  
          private Rgbx() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return (rgb << 8);
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return (0xff000000 | (pixel >> 8));
          }
      }
      public static class Xrgb extends PixelConverter {
          public static final PixelConverter instance = new Xrgb();
  
          private Xrgb() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return rgb;
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return (0xff000000 | pixel);
          }
      }
      public static class Argb extends PixelConverter {
          public static final PixelConverter instance = new Argb();
  
          private Argb() {
              alphaMask = 0xff000000;
          }
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return rgb;
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return pixel;
          }
      }
      public static class Ushort565Rgb extends PixelConverter {
          public static final PixelConverter instance = new Ushort565Rgb();
  
          private Ushort565Rgb() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return (((rgb >> (16 + 3 - 11)) & 0xf800) |
                      ((rgb >> ( 8 + 2 -  5)) & 0x07e0) |
                      ((rgb >> ( 0 + 3 -  0)) & 0x001f));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              int r, g, b;
              r = (pixel >> 11) & 0x1f;
              r = (r << 3) | (r >> 2);
              g = (pixel >>  5) & 0x3f;
              g = (g << 2) | (g >> 4);
              b = (pixel      ) & 0x1f;
              b = (b << 3) | (b >> 2);
              return (0xff000000 | (r << 16) | (g << 8) | (b));
          }
      }
      public static class Ushort555Rgbx extends PixelConverter {
          public static final PixelConverter instance = new Ushort555Rgbx();
  
          private Ushort555Rgbx() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return (((rgb >> (16 + 3 - 11)) & 0xf800) |
                      ((rgb >> ( 8 + 3 -  6)) & 0x07c0) |
                      ((rgb >> ( 0 + 3 -  1)) & 0x003e));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              int r, g, b;
              r = (pixel >> 11) & 0x1f;
              r = (r << 3) | (r >> 2);
              g = (pixel >>  6) & 0x1f;
              g = (g << 3) | (g >> 2);
              b = (pixel >>  1) & 0x1f;
              b = (b << 3) | (b >> 2);
              return (0xff000000 | (r << 16) | (g << 8) | (b));
          }
      }
      public static class Ushort555Rgb extends PixelConverter {
          public static final PixelConverter instance = new Ushort555Rgb();
  
          private Ushort555Rgb() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return (((rgb >> (16 + 3 - 10)) & 0x7c00) |
                      ((rgb >> ( 8 + 3 -  5)) & 0x03e0) |
                      ((rgb >> ( 0 + 3 -  0)) & 0x001f));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              int r, g, b;
              r = (pixel >> 10) & 0x1f;
              r = (r << 3) | (r >> 2);
              g = (pixel >>  5) & 0x1f;
              g = (g << 3) | (g >> 2);
              b = (pixel      ) & 0x1f;
              b = (b << 3) | (b >> 2);
              return (0xff000000 | (r << 16) | (g << 8) | (b));
          }
      }
      public static class Ushort4444Argb extends PixelConverter {
          public static final PixelConverter instance = new Ushort4444Argb();
  
          private Ushort4444Argb() {
              alphaMask = 0xf000;
          }
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              // use upper 4 bits for each color
              // 0xAaRrGgBb -> 0x0000ARGB
              int a = (rgb >> 16) & 0xf000;
              int r = (rgb >> 12) & 0x0f00;
              int g = (rgb >>  8) & 0x00f0;
              int b = (rgb >>  4) & 0x000f;
  
              return (a | r | g | b);
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              int a, r, g, b;
              // replicate 4 bits for each color
              // 0xARGB -> 0xAARRGGBB
              a = pixel & 0xf000;
              a = ((pixel << 16) | (pixel << 12)) & 0xff000000;
              r = pixel & 0x0f00;
              r = ((pixel << 12) | (pixel <<  8)) & 0x00ff0000;
              g = pixel & 0x00f0;
              g = ((pixel <<  8) | (pixel <<  4)) & 0x0000ff00;
              b = pixel & 0x000f;
              b = ((pixel <<  4) | (pixel <<  0)) & 0x000000ff;
  
              return (a | r | g | b);
          }
      }
      public static class Xbgr extends PixelConverter {
          public static final PixelConverter instance = new Xbgr();
  
          private Xbgr() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return (((rgb & 0xff) << 16) |
                      (rgb & 0xff00) |
                      ((rgb >> 16) & 0xff));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return (0xff000000 |
                      ((pixel & 0xff) << 16) |
                      (pixel & 0xff00) |
                      ((pixel >> 16) & 0xff));
          }
      }
      public static class Bgrx extends PixelConverter {
          public static final PixelConverter instance = new Bgrx();
  
          private Bgrx() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return ((rgb << 24) |
                      ((rgb & 0xff00) << 8) |
                      ((rgb >> 8) & 0xff00));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return (0xff000000                   |
                      ((pixel & 0xff00) << 8) |
                      ((pixel >> 8) & 0xff00) |
                      (pixel >>> 24));
          }
      }
      public static class Rgba extends PixelConverter {
          public static final PixelConverter instance = new Rgba();
  
          private Rgba() {
              alphaMask = 0x000000ff;
          }
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return ((rgb << 8) | (rgb >>> 24));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return ((pixel << 24) | (pixel >>> 8));
          }
      }
      public static class RgbaPre extends PixelConverter {
          public static final PixelConverter instance = new RgbaPre();
  
          private RgbaPre() {
              alphaMask = 0x000000ff;
          }
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              if ((rgb >> 24) == -1) {
                  return ((rgb << 8) | (rgb >>> 24));
              }
              int a = rgb >>> 24;
              int r = (rgb >> 16) & 0xff;
              int g = (rgb >>  8) & 0xff;
              int b = (rgb      ) & 0xff;
              int a2 = a + (a >> 7);
              r = (r * a2) >> 8;
              g = (g * a2) >> 8;
              b = (b * a2) >> 8;
              return ((r << 24) | (g << 16) | (b << 8) | (a));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              int a = pixel & 0xff;
              if ((a == 0xff) || (a == 0)) {
                  return ((pixel >>> 8) | (pixel << 24));
              }
              int r = pixel >>> 24;
              int g = (pixel >> 16) & 0xff;
              int b = (pixel >>  8) & 0xff;
              r = ((r << 8) - r) / a;
              g = ((g << 8) - g) / a;
              b = ((b << 8) - b) / a;
              return ((r << 24) | (g << 16) | (b << 8) | (a));
          }
      }
      public static class ArgbPre extends PixelConverter {
          public static final PixelConverter instance = new ArgbPre();
  
          private ArgbPre() {
              alphaMask = 0xff000000;
          }
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              if ((rgb >> 24) == -1) {
                  return rgb;
              }
              int a = rgb >>> 24;
              int r = (rgb >> 16) & 0xff;
              int g = (rgb >>  8) & 0xff;
              int b = (rgb      ) & 0xff;
              int a2 = a + (a >> 7);
              r = (r * a2) >> 8;
              g = (g * a2) >> 8;
              b = (b * a2) >> 8;
              return ((a << 24) | (r << 16) | (g << 8) | (b));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              int a = pixel >>> 24;
              if ((a == 0xff) || (a == 0)) {
                  return pixel;
              }
              int r = (pixel >> 16) & 0xff;
              int g = (pixel >>  8) & 0xff;
              int b = (pixel      ) & 0xff;
              r = ((r << 8) - r) / a;
              g = ((g << 8) - g) / a;
              b = ((b << 8) - b) / a;
              return ((a << 24) | (r << 16) | (g << 8) | (b));
          }
      }
      public static class ArgbBm extends PixelConverter {
          public static final PixelConverter instance = new ArgbBm();
  
          private ArgbBm() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              return (rgb | ((rgb >> 31) << 24));
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return ((pixel << 7) >> 7);
          }
      }
      public static class ByteGray extends PixelConverter {
          static final double RED_MULT = 0.299;
          static final double GRN_MULT = 0.587;
          static final double BLU_MULT = 0.114;
          public static final PixelConverter instance = new ByteGray();
  
          private ByteGray() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              int red = (rgb >> 16) & 0xff;
              int grn = (rgb >>  8) & 0xff;
              int blu = (rgb      ) & 0xff;
              return (int) (red * RED_MULT +
                            grn * GRN_MULT +
                            blu * BLU_MULT +
                            0.5);
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              return ((((((0xff << 8) | pixel) << 8) | pixel) << 8) | pixel);
          }
      }
      public static class UshortGray extends ByteGray {
          static final double SHORT_MULT = 257.0; // (65535.0 / 255.0);
          static final double USHORT_RED_MULT = RED_MULT * SHORT_MULT;
          static final double USHORT_GRN_MULT = GRN_MULT * SHORT_MULT;
          static final double USHORT_BLU_MULT = BLU_MULT * SHORT_MULT;
          public static final PixelConverter instance = new UshortGray();
  
          private UshortGray() {}
  
          public int rgbToPixel(int rgb, ColorModel cm) {
              int red = (rgb >> 16) & 0xff;
              int grn = (rgb >>  8) & 0xff;
              int blu = (rgb      ) & 0xff;
              return (int) (red * USHORT_RED_MULT +
                            grn * USHORT_GRN_MULT +
                            blu * USHORT_BLU_MULT +
                            0.5);
          }
  
          public int pixelToRgb(int pixel, ColorModel cm) {
              pixel = pixel >> 8;
              return ((((((0xff << 8) | pixel) << 8) | pixel) << 8) | pixel);
          }
      }
  }
  