awt/java/awt/image/BufferedImage.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Igor V. Stolyarov
 * @version $Revision$
 */

package java.awt.image;

import com.android.internal.awt.AndroidGraphics2D;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import org.apache.harmony.awt.gl.ImageSurface;
import org.apache.harmony.awt.gl.Surface;
import org.apache.harmony.awt.gl.image.BufferedImageSource;
import org.apache.harmony.awt.internal.nls.Messages;

/**
 * The BufferedImage class describes an Image which contains a buffer of image
 * data and includes a ColorModel and a Raster for this data. This class
 * provides methods for obtaining and setting the Raster and for manipulating
 * the ColorModel parameters.
 * 
 * @since Android 1.0
 */
public class BufferedImage extends Image implements WritableRenderedImage, Transparency {

    /**
     * The Constant TYPE_CUSTOM indicates that Image type is unknown.
     */
    public static final int TYPE_CUSTOM = 0;

    /**
     * The Constant TYPE_INT_RGB indicates an image with 8 bit RGB color
     * components, it has a DirectColorModel without alpha.
     */
    public static final int TYPE_INT_RGB = 1;

    /**
     * The Constant TYPE_INT_ARGB indicates an image with 8 bit RGBA color
     * components, it has a DirectColorModel with alpha.
     */
    public static final int TYPE_INT_ARGB = 2;

    /**
     * The Constant TYPE_INT_ARGB_PRE indicates an image with 8 bit RGBA color
     * components, it has a DirectColorModel with alpha, and image data is
     * pre-multiplied by alpha.
     */
    public static final int TYPE_INT_ARGB_PRE = 3;

    /**
     * The Constant TYPE_INT_BGR indicates an image with 8 bit RGB color
     * components, BGR color model (with the colors Blue, Green, and Red). There
     * is no alpha. The image has a DirectColorModel.
     */
    public static final int TYPE_INT_BGR = 4;

    /**
     * The Constant TYPE_3BYTE_BGR indicates an image with 8 bit RGB color
     * components, BGR color model (with the colors Blue, Green, and Red stored
     * in 3 bytes). There is no alpha. The image has a ComponentColorModel.
     */
    public static final int TYPE_3BYTE_BGR = 5;

    /**
     * The Constant TYPE_4BYTE_ABGR indicates an image with 8 bit RGBA color
     * components stored in 3 bytes and 1 byte of alpha. It has a
     * ComponentColorModel with alpha.
     */
    public static final int TYPE_4BYTE_ABGR = 6;

    /**
     * The Constant TYPE_4BYTE_ABGR_PRE indicates an image with 8 bit RGBA color
     * components stored in 3 bytes and 1 byte for alpha. The image has a
     * ComponentColorModel with alpha. The color data is pre-multiplied with
     * alpha.
     */
    public static final int TYPE_4BYTE_ABGR_PRE = 7;

    /**
     * The Constant TYPE_USHORT_565_RGB indicates an image with 565 RGB color
     * components (5-bits red, 6-bits green, 5-bits blue) with no alpha. This
     * image has a DirectColorModel.
     */
    public static final int TYPE_USHORT_565_RGB = 8;

    /**
     * The Constant TYPE_USHORT_555_RGB indicates an image with 555 RGB color
     * components (5-bits red, 5-bits green, 5-bits blue) with no alpha. This
     * image has a DirectColorModel.
     */
    public static final int TYPE_USHORT_555_RGB = 9;

    /**
     * The Constant TYPE_BYTE_GRAY indicates a unsigned byte image. This image
     * has a ComponentColorModel with a CS_GRAY ColorSpace.
     */
    public static final int TYPE_BYTE_GRAY = 10;

    /**
     * The Constant TYPE_USHORT_GRAY indicates an unsigned short image. This
     * image has a ComponentColorModel with a CS_GRAY ColorSpace.
     */
    public static final int TYPE_USHORT_GRAY = 11;

    /**
     * The Constant TYPE_BYTE_BINARY indicates an opaque byte-packed 1, 2 or 4
     * bit image. The image has an IndexColorModel without alpha.
     */
    public static final int TYPE_BYTE_BINARY = 12;

    /**
     * The Constant TYPE_BYTE_INDEXED indicates an indexed byte image.
     */
    public static final int TYPE_BYTE_INDEXED = 13;

    /**
     * The Constant ALPHA_MASK.
     */
    private static final int ALPHA_MASK = 0xff000000;

    /**
     * The Constant RED_MASK.
     */
    private static final int RED_MASK = 0x00ff0000;

    /**
     * The Constant GREEN_MASK.
     */
    private static final int GREEN_MASK = 0x0000ff00;

    /**
     * The Constant BLUE_MASK.
     */
    private static final int BLUE_MASK = 0x000000ff;

    /**
     * The Constant RED_BGR_MASK.
     */
    private static final int RED_BGR_MASK = 0x000000ff;

    /**
     * The Constant GREEN_BGR_MASK.
     */
    private static final int GREEN_BGR_MASK = 0x0000ff00;

    /**
     * The Constant BLUE_BGR_MASK.
     */
    private static final int BLUE_BGR_MASK = 0x00ff0000;

    /**
     * The Constant RED_565_MASK.
     */
    private static final int RED_565_MASK = 0xf800;

    /**
     * The Constant GREEN_565_MASK.
     */
    private static final int GREEN_565_MASK = 0x07e0;

    /**
     * The Constant BLUE_565_MASK.
     */
    private static final int BLUE_565_MASK = 0x001f;

    /**
     * The Constant RED_555_MASK.
     */
    private static final int RED_555_MASK = 0x7c00;

    /**
     * The Constant GREEN_555_MASK.
     */
    private static final int GREEN_555_MASK = 0x03e0;

    /**
     * The Constant BLUE_555_MASK.
     */
    private static final int BLUE_555_MASK = 0x001f;

    /**
     * The cm.
     */
    private ColorModel cm;

    /**
     * The raster.
     */
    private final WritableRaster raster;

    /**
     * The image type.
     */
    private final int imageType;

    /**
     * The properties.
     */
    private Hashtable<?, ?> properties;

    // Surface of the Buffered Image - used for blitting one Buffered Image
    // on the other one or on the Component
    /**
     * The image surf.
     */
    private final ImageSurface imageSurf;

    /**
     * Instantiates a new BufferedImage with the specified ColorModel, and
     * WritableRaster objects. The Raster data can be be divided or multiplied
     * by alpha. It depends on the alphaPremultiplied state in the ColorModel.
     * 
     * @param cm
     *            the ColorModel of the new image.
     * @param raster
     *            the WritableRaster of the new image.
     * @param isRasterPremultiplied
     *            if true the data of the specified Raster is pre-multiplied by
     *            alpha.
     * @param properties
     *            the properties of new Image.
     */
    public BufferedImage(ColorModel cm, WritableRaster raster, boolean isRasterPremultiplied,
            Hashtable<?, ?> properties) {
        if (!cm.isCompatibleRaster(raster)) {
            // awt.4D=The raster is incompatible with this ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$
        }

        if (raster.getMinX() != 0 || raster.getMinY() != 0) {
            // awt.228=minX or minY of this raster not equal to zero
            throw new IllegalArgumentException(Messages.getString("awt.228")); //$NON-NLS-1$
        }

        this.cm = cm;
        this.raster = raster;
        this.properties = properties;

        coerceData(isRasterPremultiplied);

        imageType = Surface.getType(cm, raster);

        imageSurf = createImageSurface(imageType);
    }

    /**
     * Instantiates a new BufferedImage with the specified width, height
     * predefined image type (TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED) and the
     * specified IndexColorModel.
     * 
     * @param width
     *            the width of new image.
     * @param height
     *            the height of new image.
     * @param imageType
     *            the predefined image type.
     * @param cm
     *            the specified IndexColorModel.
     */
    public BufferedImage(int width, int height, int imageType, IndexColorModel cm) {
        switch (imageType) {
            case TYPE_BYTE_BINARY:
                if (cm.hasAlpha()) {
                    // awt.227=This image type can't have alpha
                    throw new IllegalArgumentException(Messages.getString("awt.227")); //$NON-NLS-1$
                }
                int pixel_bits = 0;
                int mapSize = cm.getMapSize();
                if (mapSize <= 2) {
                    pixel_bits = 1;
                } else if (mapSize <= 4) {
                    pixel_bits = 2;
                } else if (mapSize <= 16) {
                    pixel_bits = 4;
                } else {
                    // awt.221=The imageType is TYPE_BYTE_BINARY and the color
                    // map has more than 16 entries
                    throw new IllegalArgumentException(Messages.getString("awt.221")); //$NON-NLS-1$
                }

                raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width, height, 1,
                        pixel_bits, null);
                break;

            case TYPE_BYTE_INDEXED:
                raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 1,
                        null);
                break;

            default:
                // awt.222=The imageType is not TYPE_BYTE_BINARY or
                // TYPE_BYTE_INDEXED
                throw new IllegalArgumentException(Messages.getString("awt.222")); //$NON-NLS-1$

        }

        if (!cm.isCompatibleRaster(raster)) {
            // awt.223=The imageType is not compatible with ColorModel
            throw new IllegalArgumentException(Messages.getString("awt.223")); //$NON-NLS-1$
        }

        this.cm = cm;
        this.imageType = imageType;
        imageSurf = createImageSurface(imageType);

    }

    /**
     * Instantiates a new BufferedImage with the specified width, height and
     * predefined image type.
     * 
     * @param width
     *            the width of new image.
     * @param height
     *            the height of new image.
     * @param imageType
     *            the predefined image type.
     */
    public BufferedImage(int width, int height, int imageType) {

        switch (imageType) {
            case TYPE_INT_RGB:
                cm = new DirectColorModel(24, RED_MASK, GREEN_MASK, BLUE_MASK);
                raster = cm.createCompatibleWritableRaster(width, height);
                break;

            case TYPE_INT_ARGB:
                cm = ColorModel.getRGBdefault();
                raster = cm.createCompatibleWritableRaster(width, height);
                break;

            case TYPE_INT_ARGB_PRE:
                cm = new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), 32, RED_MASK,
                        GREEN_MASK, BLUE_MASK, ALPHA_MASK, true, DataBuffer.TYPE_INT);

                raster = cm.createCompatibleWritableRaster(width, height);
                break;

            case TYPE_INT_BGR:
                cm = new DirectColorModel(24, RED_BGR_MASK, GREEN_BGR_MASK, BLUE_BGR_MASK);

                raster = cm.createCompatibleWritableRaster(width, height);
                break;

            case TYPE_3BYTE_BGR: {
                int bits[] = {
                        8, 8, 8
                };
                int bandOffsets[] = {
                        2, 1, 0
                };
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits,
                        false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);

                raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height,
                        width * 3, 3, bandOffsets, null);
            }
                break;

            case TYPE_4BYTE_ABGR: {
                int bits[] = {
                        8, 8, 8, 8
                };
                int bandOffsets[] = {
                        3, 2, 1, 0
                };
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits,
                        true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);

                raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height,
                        width * 4, 4, bandOffsets, null);
            }
                break;

            case TYPE_4BYTE_ABGR_PRE: {
                int bits[] = {
                        8, 8, 8, 8
                };
                int bandOffsets[] = {
                        3, 2, 1, 0
                };
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits,
                        true, true, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);

                raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height,
                        width * 4, 4, bandOffsets, null);
            }
                break;

            case TYPE_USHORT_565_RGB:
                cm = new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), 16,
                        RED_565_MASK, GREEN_565_MASK, BLUE_565_MASK, 0, false,
                        DataBuffer.TYPE_USHORT);

                raster = cm.createCompatibleWritableRaster(width, height);
                break;

            case TYPE_USHORT_555_RGB:
                cm = new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), 15,
                        RED_555_MASK, GREEN_555_MASK, BLUE_555_MASK, 0, false,
                        DataBuffer.TYPE_USHORT);

                raster = cm.createCompatibleWritableRaster(width, height);
                break;

            case TYPE_BYTE_GRAY: {
                int bits[] = {
                    8
                };
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), bits,
                        false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);

                raster = cm.createCompatibleWritableRaster(width, height);
            }
                break;

            case TYPE_USHORT_GRAY: {
                int bits[] = {
                    16
                };
                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), bits,
                        false, false, Transparency.OPAQUE, DataBuffer.TYPE_USHORT);
                raster = cm.createCompatibleWritableRaster(width, height);
            }
                break;

            case TYPE_BYTE_BINARY: {
                int colorMap[] = {
                        0, 0xffffff
                };
                cm = new IndexColorModel(1, 2, colorMap, 0, false, -1, DataBuffer.TYPE_BYTE);

                raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width, height, 1, 1, null);
            }
                break;

            case TYPE_BYTE_INDEXED: {
                int colorMap[] = new int[256];
                int i = 0;
                for (int r = 0; r < 256; r += 51) {
                    for (int g = 0; g < 256; g += 51) {
                        for (int b = 0; b < 256; b += 51) {
                            colorMap[i] = (r << 16) | (g << 8) | b;
                            i++;
                        }
                    }
                }

                int gray = 0x12;
                for (; i < 256; i++, gray += 6) {
                    colorMap[i] = (gray << 16) | (gray << 8) | gray;
                }
                cm = new IndexColorModel(8, 256, colorMap, 0, false, -1, DataBuffer.TYPE_BYTE);
                raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 1,
                        null);

            }
                break;
            default:
                // awt.224=Unknown image type
                throw new IllegalArgumentException(Messages.getString("awt.224")); //$NON-NLS-1$
        }
        this.imageType = imageType;
        imageSurf = createImageSurface(imageType);
    }

    @Override
    public Object getProperty(String name, ImageObserver observer) {
        return getProperty(name);
    }

    public Object getProperty(String name) {
        if (name == null) {
            // awt.225=Property name is null
            throw new NullPointerException(Messages.getString("awt.225")); //$NON-NLS-1$
        }
        if (properties == null) {
            return Image.UndefinedProperty;
        }
        Object property = properties.get(name);
        if (property == null) {
            property = Image.UndefinedProperty;
        }
        return property;
    }

    public WritableRaster copyData(WritableRaster outRaster) {
        if (outRaster == null) {
            outRaster = Raster.createWritableRaster(raster.getSampleModel(), new Point(raster
                    .getSampleModelTranslateX(), raster.getSampleModelTranslateY()));
        }

        int w = outRaster.getWidth();
        int h = outRaster.getHeight();
        int minX = outRaster.getMinX();
        int minY = outRaster.getMinY();

        Object data = null;

        data = raster.getDataElements(minX, minY, w, h, data);
        outRaster.setDataElements(minX, minY, w, h, data);

        return outRaster;
    }

    public Raster getData(Rectangle rect) {
        int minX = rect.x;
        int minY = rect.y;
        int w = rect.width;
        int h = rect.height;

        SampleModel sm = raster.getSampleModel();
        SampleModel nsm = sm.createCompatibleSampleModel(w, h);
        WritableRaster outr = Raster.createWritableRaster(nsm, rect.getLocation());
        Object data = null;

        data = raster.getDataElements(minX, minY, w, h, data);
        outr.setDataElements(minX, minY, w, h, data);
        return outr;
    }

    public Vector<RenderedImage> getSources() {
        return null;
    }

    public String[] getPropertyNames() {
        if (properties == null) {
            return null;
        }
        Vector<String> v = new Vector<String>();
        for (Enumeration<?> e = properties.keys(); e.hasMoreElements();) {
            try {
                v.add((String)e.nextElement());
            } catch (ClassCastException ex) {
            }
        }
        int size = v.size();
        if (size > 0) {
            String names[] = new String[size];
            for (int i = 0; i < size; i++) {
                names[i] = v.elementAt(i);
            }
            return names;
        }
        return null;
    }

    /**
     * Returns the string representation of this BufferedImage object.
     * 
     * @return the string representation of this BufferedImage object.
     */
    @Override
    public String toString() {
        return "BufferedImage@" + Integer.toHexString(hashCode()) + //$NON-NLS-1$
                ": type = " + imageType + " " + cm + " " + raster; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
    }

    public WritableRaster getWritableTile(int tileX, int tileY) {
        return raster;
    }

    /**
     * Gets the WritableRaster of this BufferedImage.
     * 
     * @return the WritableRaster of this BufferedImage.
     */
    public WritableRaster getRaster() {
        return raster;
    }

    /**
     * Gets a WritableRaster object which contains the alpha channel of
     * BufferedImage object with ColorModel objects that supports a separate
     * alpha channel such as ComponentColorModel or DirectColorModel.
     * 
     * @return the WritableRaster object which contains the alpha channel of
     *         this BufferedImage.
     */
    public WritableRaster getAlphaRaster() {
        return cm.getAlphaRaster(raster);
    }

    public void removeTileObserver(TileObserver to) {
    }

    public void addTileObserver(TileObserver to) {
    }

    public SampleModel getSampleModel() {
        return raster.getSampleModel();
    }

    public void setData(Raster r) {

        Rectangle from = r.getBounds();
        Rectangle to = raster.getBounds();
        Rectangle intersection = to.intersection(from);

        int minX = intersection.x;
        int minY = intersection.y;
        int w = intersection.width;
        int h = intersection.height;

        Object data = null;

        data = r.getDataElements(minX, minY, w, h, data);
        raster.setDataElements(minX, minY, w, h, data);
    }

    public Raster getTile(int tileX, int tileY) {
        if (tileX == 0 && tileY == 0) {
            return raster;
        }
        // awt.226=Both tileX and tileY are not equal to 0
        throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$
    }

    public Raster getData() {
        int w = raster.getWidth();
        int h = raster.getHeight();
        int minX = raster.getMinX();
        int minY = raster.getMinY();

        WritableRaster outr = Raster.createWritableRaster(raster.getSampleModel(), new Point(raster
                .getSampleModelTranslateX(), raster.getSampleModelTranslateY()));

        Object data = null;

        data = raster.getDataElements(minX, minY, w, h, data);
        outr.setDataElements(minX, minY, w, h, data);

        return outr;
    }

    @Override
    public ImageProducer getSource() {
        return new BufferedImageSource(this, properties);
    }

    @Override
    public int getWidth(ImageObserver observer) {
        return raster.getWidth();
    }

    @Override
    public int getHeight(ImageObserver observer) {
        return raster.getHeight();
    }

    public ColorModel getColorModel() {
        return cm;
    }

    /**
     * Gets the rectangular area of this BufferedImage as a subimage.
     * 
     * @param x
     *            the x coordinate.
     * @param y
     *            the y coordinate.
     * @param w
     *            the width of the subimage.
     * @param h
     *            the height of the subimage.
     * @return the BufferedImage.
     */
    public BufferedImage getSubimage(int x, int y, int w, int h) {
        WritableRaster wr = raster.createWritableChild(x, y, w, h, 0, 0, null);
        return new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), properties);
    }

    public Point[] getWritableTileIndices() {
        Point points[] = new Point[1];
        points[0] = new Point(0, 0);
        return points;
    }

    /**
     * Creates the Graphics2D object which allows to draw into this
     * BufferedImage.
     * 
     * @return the graphics2D object.
     */
    public Graphics2D createGraphics() {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        // return ge.createGraphics(this);
        // ???AWT hack, FIXME
        // return AndroidGraphics2D.getInstance();
        // throw new RuntimeException("Not implemented!");
        return null;
    }

    @Override
    public Graphics getGraphics() {
        return createGraphics();
    }

    /**
     * Coerces the data to achieve the state which is specified by the
     * isAlphaPremultiplied variable.
     * 
     * @param isAlphaPremultiplied
     *            the is alpha pre-multiplied state.
     */
    public void coerceData(boolean isAlphaPremultiplied) {
        if (cm.hasAlpha() && cm.isAlphaPremultiplied() != isAlphaPremultiplied) {
            cm = cm.coerceData(raster, isAlphaPremultiplied);
        }
    }

    /**
     * Gets an array of colors in the TYPE_INT_ARGB color model and default sRGB
     * color space of the specified area of this BufferedImage. The result array
     * is composed by the following algorithm:
     * <p>
     * pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)]
     * </p>
     * 
     * @param startX
     *            the start X area coordinate.
     * @param startY
     *            the start Y area coordinate.
     * @param w
     *            the width of the area.
     * @param h
     *            the height of the area.
     * @param rgbArray
     *            the result array will be stored to this array.
     * @param offset
     *            the offset of the rgbArray array.
     * @param scansize
     *            the scanline stride for the rgbArray.
     * @return an array of colors for the specified area.
     */
    public int[] getRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset,
            int scansize) {
        if (rgbArray == null) {
            rgbArray = new int[offset + h * scansize];
        }

        int off = offset;
        for (int y = startY; y < startY + h; y++, off += scansize) {
            int i = off;
            for (int x = startX; x < startX + w; x++, i++) {
                rgbArray[i] = cm.getRGB(raster.getDataElements(x, y, null));
            }
        }
        return rgbArray;
    }

    /**
     * Sets RGB values from the specified array to the specified BufferedImage
     * area. The pixels are in the default RGB color model (TYPE_INT_ARGB) and
     * default sRGB color space.
     * 
     * @param startX
     *            the start X coordinate.
     * @param startY
     *            the start Y coordinate.
     * @param w
     *            the width of the BufferedImage area.
     * @param h
     *            the height of the BufferedImage area.
     * @param rgbArray
     *            the array of RGB values.
     * @param offset
     *            the offset of the rgbArray array.
     * @param scansize
     *            the scanline stride for the rgbArray.
     */
    public void setRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset,
            int scansize) {
        int off = offset;
        for (int y = startY; y < startY + h; y++, off += scansize) {
            int i = off;
            for (int x = startX; x < startX + w; x++, i++) {
                raster.setDataElements(x, y, cm.getDataElements(rgbArray[i], null));
            }
        }
    }

    /**
     * Sets a the specified RGB value to the specified pixel of this
     * BufferedImage. The pixel should be in the default RGB color model
     * (TYPE_INT_ARGB) and default sRGB color space.
     * 
     * @param x
     *            the X coordinate of the pixel.
     * @param y
     *            the Y coordinate of the pixel.
     * @param rgb
     *            the RGB value to be set.
     */
    public synchronized void setRGB(int x, int y, int rgb) {
        raster.setDataElements(x, y, cm.getDataElements(rgb, null));
    }

    public boolean isTileWritable(int tileX, int tileY) {
        if (tileX == 0 && tileY == 0) {
            return true;
        }
        // awt.226=Both tileX and tileY are not equal to 0
        throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$
    }

    public void releaseWritableTile(int tileX, int tileY) {
    }

    /**
     * Gets a color in the TYPE_INT_ARGB color model and default sRGB color
     * space of the specified pixel.
     * 
     * @param x
     *            the X coordinate of the pixel.
     * @param y
     *            the Y coordinate of the pixel.
     * @return the color of the specified pixel in the TYPE_INT_ARGB color model
     *         and default sRGB color space.
     */
    public int getRGB(int x, int y) {
        return cm.getRGB(raster.getDataElements(x, y, null));
    }

    /**
     * Returns true if alpha is pre-multiplied, false if alpha is not
     * pre-multiplied or there is no alpha.
     * 
     * @return true if alpha is pre-multiplied, false if alpha is not
     *         pre-multiplied or there is no alpha.
     */
    public boolean isAlphaPremultiplied() {
        return cm.isAlphaPremultiplied();
    }

    public boolean hasTileWriters() {
        return true;
    }

    @Override
    public void flush() {
        imageSurf.dispose();
    }

    public int getWidth() {
        return raster.getWidth();
    }

    /**
     * Gets the image type.
     * 
     * @return the image type.
     */
    public int getType() {
        return imageType;
    }

    public int getTileWidth() {
        return raster.getWidth();
    }

    public int getTileHeight() {
        return raster.getHeight();
    }

    public int getTileGridYOffset() {
        return raster.getSampleModelTranslateY();
    }

    public int getTileGridXOffset() {
        return raster.getSampleModelTranslateX();
    }

    public int getNumYTiles() {
        return 1;
    }

    public int getNumXTiles() {
        return 1;
    }

    public int getMinY() {
        return raster.getMinY();
    }

    public int getMinX() {
        return raster.getMinX();
    }

    public int getMinTileY() {
        return 0;
    }

    public int getMinTileX() {
        return 0;
    }

    public int getHeight() {
        return raster.getHeight();
    }

    /**
     * Creates the image surface.
     * 
     * @param type
     *            the type.
     * @return the image surface.
     */
    private ImageSurface createImageSurface(int type) {
        return new ImageSurface(getColorModel(), getRaster(), type);
    }

    /**
     * Gets the image surface.
     * 
     * @return the image surface.
     */
    ImageSurface getImageSurface() {
        return imageSurf;
    }

    public int getTransparency() {
        return cm.getTransparency();
    }
}