Back to index...

	/*
	* 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);
	}
	}
	}

Back to index...