projects/dwt-mac: dwt/graphics/ImageData.d comparison

comparison dwt/graphics/ImageData.d @ 0:380af2bdd8e5

Upload of whole dwt tree

author	Jacob Carlborg <doob@me.com> <jacob.carlborg@gmail.com>
date	Sat, 09 Aug 2008 17:00:02 +0200
parents
children	ab8b5765e3d1

comparison

equal deleted inserted replaced

--1:000000000000
+:380af2bdd8e5
+/*******************************************************************************
+* Copyright (c) 2000, 2007 IBM Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     IBM Corporation - initial API and implementation
+*******************************************************************************/
+module dwt.graphics.ImageData;
+import dwt.dwthelper.utils;
+import java.io.InputStream;
+import dwt.DWT;
+import dwt.DWTException;
+import dwt.internal.CloneableCompatibility;
+/**
+* Instances of this class are device-independent descriptions
+* of images. They are typically used as an intermediate format
+* between loading from or writing to streams and creating an
+* <code>Image</code>.
+* <p>
+* Note that the public fields <code>x</code>, <code>y</code>,
+* <code>disposalMethod</code> and <code>delayTime</code> are
+* typically only used when the image is in a set of images used
+* for animation.
+* </p>
+*
+* @see Image
+* @see ImageLoader
+*/
+public final class ImageData implements CloneableCompatibility {
+/**
+* The width of the image, in pixels.
+*/
+public int width;
+/**
+* The height of the image, in pixels.
+*/
+public int height;
+/**
+* The color depth of the image, in bits per pixel.
+* <p>
+* Note that a depth of 8 or less does not necessarily
+* mean that the image is palette indexed, or
+* conversely that a depth greater than 8 means that
+* the image is direct color.  Check the associated
+* PaletteData's isDirect field for such determinations.
+*/
+public int depth;
+/**
+* The scanline padding.
+* <p>
+* If one scanline of the image is not a multiple of
+* this number, it will be padded with zeros until it is.
+* </p>
+*/
+public int scanlinePad;
+/**
+* The number of bytes per scanline.
+* <p>
+* This is a multiple of the scanline padding.
+* </p>
+*/
+public int bytesPerLine;
+/**
+* The pixel data of the image.
+* <p>
+* Note that for 16 bit depth images the pixel data is stored
+* in least significant byte order; however, for 24bit and
+* 32bit depth images the pixel data is stored in most
+* significant byte order.
+* </p>
+*/
+public byte[] data;
+/**
+* The color table for the image.
+*/
+public PaletteData palette;
+/**
+* The transparent pixel.
+* <p>
+* Pixels with this value are transparent.
+* </p><p>
+* The default is -1 which means 'no transparent pixel'.
+* </p>
+*/
+public int transparentPixel;
+/**
+* An icon-specific field containing the data from the icon mask.
+* <p>
+* This is a 1 bit bitmap stored with the most significant
+* bit first.  The number of bytes per scanline is
+* '((width + 7) / 8 + (maskPad - 1)) / maskPad * maskPad'.
+* </p><p>
+* The default is null which means 'no transparency mask'.
+* </p>
+*/
+public byte[] maskData;
+/**
+* An icon-specific field containing the scanline pad of the mask.
+* <p>
+* If one scanline of the transparency mask is not a
+* multiple of this number, it will be padded with zeros until
+* it is.
+* </p>
+*/
+public int maskPad;
+/**
+* The alpha data of the image.
+* <p>
+* Every pixel can have an <em>alpha blending</em> value that
+* varies from 0, meaning fully transparent, to 255 meaning
+* fully opaque.  The number of bytes per scanline is
+* 'width'.
+* </p>
+*/
+public byte[] alphaData;
+/**
+* The global alpha value to be used for every pixel.
+* <p>
+* If this value is set, the <code>alphaData</code> field
+* is ignored and when the image is rendered each pixel
+* will be blended with the background an amount
+* proportional to this value.
+* </p><p>
+* The default is -1 which means 'no global alpha value'
+* </p>
+*/
+public int alpha;
+/**
+* The type of file from which the image was read.
+*
+* It is expressed as one of the following values:
+* <dl>
+* <dt><code>IMAGE_BMP</code></dt>
+* <dd>Windows BMP file format, no compression</dd>
+* <dt><code>IMAGE_BMP_RLE</code></dt>
+* <dd>Windows BMP file format, RLE compression if appropriate</dd>
+* <dt><code>IMAGE_GIF</code></dt>
+* <dd>GIF file format</dd>
+* <dt><code>IMAGE_ICO</code></dt>
+* <dd>Windows ICO file format</dd>
+* <dt><code>IMAGE_JPEG</code></dt>
+* <dd>JPEG file format</dd>
+* <dt><code>IMAGE_PNG</code></dt>
+* <dd>PNG file format</dd>
+* </dl>
+*/
+public int type;
+/**
+* The x coordinate of the top left corner of the image
+* within the logical screen (this field corresponds to
+* the GIF89a Image Left Position value).
+*/
+public int x;
+/**
+* The y coordinate of the top left corner of the image
+* within the logical screen (this field corresponds to
+* the GIF89a Image Top Position value).
+*/
+public int y;
+/**
+* A description of how to dispose of the current image
+* before displaying the next.
+*
+* It is expressed as one of the following values:
+* <dl>
+* <dt><code>DM_UNSPECIFIED</code></dt>
+* <dd>disposal method not specified</dd>
+* <dt><code>DM_FILL_NONE</code></dt>
+* <dd>do nothing - leave the image in place</dd>
+* <dt><code>DM_FILL_BACKGROUND</code></dt>
+* <dd>fill with the background color</dd>
+* <dt><code>DM_FILL_PREVIOUS</code></dt>
+* <dd>restore the previous picture</dd>
+* </dl>
+* (this field corresponds to the GIF89a Disposal Method value)
+*/
+public int disposalMethod;
+/**
+* The time to delay before displaying the next image
+* in an animation (this field corresponds to the GIF89a
+* Delay Time value).
+*/
+public int delayTime;
+/**
+* Arbitrary channel width data to 8-bit conversion table.
+*/
+static final byte[][] ANY_TO_EIGHT = new byte[9][];
+static {
+for (int b = 0; b < 9; ++b) {
+byte[] data = ANY_TO_EIGHT[b] = new byte[1 << b];
+if (b is 0) continue;
+int inc = 0;
+for (int bit = 0x10000; (bit >>= b) !is 0;) inc |= bit;
+for (int v = 0, p = 0; v < 0x10000; v+= inc) data[p++] = (byte)(v >> 8);
+}
+}
+static final byte[] ONE_TO_ONE_MAPPING = ANY_TO_EIGHT[8];
+/**
+* Scaled 8x8 Bayer dither matrix.
+*/
+static final int[][] DITHER_MATRIX = {
+{ 0xfc0000, 0x7c0000, 0xdc0000, 0x5c0000, 0xf40000, 0x740000, 0xd40000, 0x540000 },
+{ 0x3c0000, 0xbc0000, 0x1c0000, 0x9c0000, 0x340000, 0xb40000, 0x140000, 0x940000 },
+{ 0xcc0000, 0x4c0000, 0xec0000, 0x6c0000, 0xc40000, 0x440000, 0xe40000, 0x640000 },
+{ 0x0c0000, 0x8c0000, 0x2c0000, 0xac0000, 0x040000, 0x840000, 0x240000, 0xa40000 },
+{ 0xf00000, 0x700000, 0xd00000, 0x500000, 0xf80000, 0x780000, 0xd80000, 0x580000 },
+{ 0x300000, 0xb00000, 0x100000, 0x900000, 0x380000, 0xb80000, 0x180000, 0x980000 },
+{ 0xc00000, 0x400000, 0xe00000, 0x600000, 0xc80000, 0x480000, 0xe80000, 0x680000 },
+{ 0x000000, 0x800000, 0x200000, 0xa00000, 0x080000, 0x880000, 0x280000, 0xa80000 }
+};
+/**
+* Constructs a new, empty ImageData with the given width, height,
+* depth and palette. The data will be initialized to an (all zero)
+* array of the appropriate size.
+*
+* @param width the width of the image
+* @param height the height of the image
+* @param depth the depth of the image
+* @param palette the palette of the image (must not be null)
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if the width or height is negative, or if the depth is not
+*          one of 1, 2, 4, 8, 16, 24 or 32</li>
+*    <li>ERROR_NULL_ARGUMENT - if the palette is null</li>
+* </ul>
+*/
+public ImageData(int width, int height, int depth, PaletteData palette) {
+this(width, height, depth, palette,
+4, null, 0, null,
+null, -1, -1, DWT.IMAGE_UNDEFINED,
+0, 0, 0, 0);
+}
+/**
+* Constructs a new, empty ImageData with the given width, height,
+* depth, palette, scanlinePad and data.
+*
+* @param width the width of the image
+* @param height the height of the image
+* @param depth the depth of the image
+* @param palette the palette of the image
+* @param scanlinePad the padding of each line, in bytes
+* @param data the data of the image
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if the width or height is negative, or if the depth is not
+*          one of 1, 2, 4, 8, 16, 24 or 32, or the data array is too small to contain the image data</li>
+*    <li>ERROR_NULL_ARGUMENT - if the palette or data is null</li>
+*    <li>ERROR_CANNOT_BE_ZERO - if the scanlinePad is zero</li>
+* </ul>
+*/
+public ImageData(int width, int height, int depth, PaletteData palette, int scanlinePad, byte[] data) {
+this(width, height, depth, palette,
+scanlinePad, checkData(data), 0, null,
+null, -1, -1, DWT.IMAGE_UNDEFINED,
+0, 0, 0, 0);
+}
+/**
+* Constructs an <code>ImageData</code> loaded from the specified
+* input stream. Throws an error if an error occurs while loading
+* the image, or if the image has an unsupported type.  Application
+* code is still responsible for closing the input stream.
+* <p>
+* This constructor is provided for convenience when loading a single
+* image only. If the stream contains multiple images, only the first
+* one will be loaded. To load multiple images, use
+* <code>ImageLoader.load()</code>.
+* </p><p>
+* This constructor may be used to load a resource as follows:
+* </p>
+* <pre>
+*     static ImageData loadImageData (Class clazz, String string) {
+*          InputStream stream = clazz.getResourceAsStream (string);
+*          if (stream is null) return null;
+*          ImageData imageData = null;
+*          try {
+*               imageData = new ImageData (stream);
+*          } catch (DWTException ex) {
+*          } finally {
+*               try {
+*                    stream.close ();
+*               } catch (IOException ex) {}
+*          }
+*          return imageData;
+*     }
+* </pre>
+*
+* @param stream the input stream to load the image from (must not be null)
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the stream is null</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_IO - if an IO error occurs while reading from the stream</li>
+*    <li>ERROR_INVALID_IMAGE - if the image stream contains invalid data</li>
+*    <li>ERROR_UNSUPPORTED_FORMAT - if the image stream contains an unrecognized format</li>
+* </ul>
+*
+* @see ImageLoader#load(InputStream)
+*/
+public ImageData(InputStream stream) {
+ImageData[] data = ImageDataLoader.load(stream);
+if (data.length < 1) DWT.error(DWT.ERROR_INVALID_IMAGE);
+ImageData i = data[0];
+setAllFields(
+i.width,
+i.height,
+i.depth,
+i.scanlinePad,
+i.bytesPerLine,
+i.data,
+i.palette,
+i.transparentPixel,
+i.maskData,
+i.maskPad,
+i.alphaData,
+i.alpha,
+i.type,
+i.x,
+i.y,
+i.disposalMethod,
+i.delayTime);
+}
+/**
+* Constructs an <code>ImageData</code> loaded from a file with the
+* specified name. Throws an error if an error occurs loading the
+* image, or if the image has an unsupported type.
+* <p>
+* This constructor is provided for convenience when loading a single
+* image only. If the file contains multiple images, only the first
+* one will be loaded. To load multiple images, use
+* <code>ImageLoader.load()</code>.
+* </p>
+*
+* @param filename the name of the file to load the image from (must not be null)
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if the file name is null</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_IO - if an IO error occurs while reading from the file</li>
+*    <li>ERROR_INVALID_IMAGE - if the image file contains invalid data</li>
+*    <li>ERROR_UNSUPPORTED_FORMAT - if the image file contains an unrecognized format</li>
+* </ul>
+*/
+public ImageData(String filename) {
+ImageData[] data = ImageDataLoader.load(filename);
+if (data.length < 1) DWT.error(DWT.ERROR_INVALID_IMAGE);
+ImageData i = data[0];
+setAllFields(
+i.width,
+i.height,
+i.depth,
+i.scanlinePad,
+i.bytesPerLine,
+i.data,
+i.palette,
+i.transparentPixel,
+i.maskData,
+i.maskPad,
+i.alphaData,
+i.alpha,
+i.type,
+i.x,
+i.y,
+i.disposalMethod,
+i.delayTime);
+}
+/**
+* Prevents uninitialized instances from being created outside the package.
+*/
+ImageData() {
+}
+/**
+* Constructs an image data by giving values for all non-computable fields.
+* <p>
+* This method is for internal use, and is not described further.
+* </p>
+*/
+ImageData(
+int width, int height, int depth, PaletteData palette,
+int scanlinePad, byte[] data, int maskPad, byte[] maskData,
+byte[] alphaData, int alpha, int transparentPixel, int type,
+int x, int y, int disposalMethod, int delayTime)
+{
+if (palette is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (!(depth is 1 || depth is 2 || depth is 4 || depth is 8
+|| depth is 16 || depth is 24 || depth is 32)) {
+DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+}
+if (width <= 0 || height <= 0) {
+DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+}
+if (scanlinePad is 0) DWT.error (DWT.ERROR_CANNOT_BE_ZERO);
+int bytesPerLine = (((width * depth + 7) / 8) + (scanlinePad - 1))
+/ scanlinePad * scanlinePad;
+/*
+* When the image is being loaded from a PNG, we need to use the theoretical minimum
+* number of bytes per line to check whether there is enough data, because the actual
+* number of bytes per line is calculated based on the given depth, which may be larger
+* than the actual depth of the PNG.
+*/
+int minBytesPerLine = type is DWT.IMAGE_PNG ? ((((width + 7) / 8) + 3) / 4) * 4 : bytesPerLine;
+if (data !is null && data.length < minBytesPerLine * height) {
+DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+}
+setAllFields(
+width,
+height,
+depth,
+scanlinePad,
+bytesPerLine,
+data !is null ? data : new byte[bytesPerLine * height],
+palette,
+transparentPixel,
+maskData,
+maskPad,
+alphaData,
+alpha,
+type,
+x,
+y,
+disposalMethod,
+delayTime);
+}
+/**
+* Initializes all fields in the receiver. This method must be called
+* by all public constructors to ensure that all fields are initialized
+* for a new ImageData object. If a new field is added to the class,
+* then it must be added to this method.
+* <p>
+* This method is for internal use, and is not described further.
+* </p>
+*/
+void setAllFields(int width, int height, int depth, int scanlinePad,
+int bytesPerLine, byte[] data, PaletteData palette, int transparentPixel,
+byte[] maskData, int maskPad, byte[] alphaData, int alpha,
+int type, int x, int y, int disposalMethod, int delayTime) {
+this.width = width;
+this.height = height;
+this.depth = depth;
+this.scanlinePad = scanlinePad;
+this.bytesPerLine = bytesPerLine;
+this.data = data;
+this.palette = palette;
+this.transparentPixel = transparentPixel;
+this.maskData = maskData;
+this.maskPad = maskPad;
+this.alphaData = alphaData;
+this.alpha = alpha;
+this.type = type;
+this.x = x;
+this.y = y;
+this.disposalMethod = disposalMethod;
+this.delayTime = delayTime;
+}
+/**
+* Invokes internal DWT functionality to create a new instance of
+* this class.
+* <p>
+* <b>IMPORTANT:</b> This method is <em>not</em> part of the public
+* API for <code>ImageData</code>. It is marked public only so that it
+* can be shared within the packages provided by DWT. It is subject
+* to change without notice, and should never be called from
+* application code.
+* </p>
+* <p>
+* This method is for internal use, and is not described further.
+* </p>
+*/
+public static ImageData internal_new(
+int width, int height, int depth, PaletteData palette,
+int scanlinePad, byte[] data, int maskPad, byte[] maskData,
+byte[] alphaData, int alpha, int transparentPixel, int type,
+int x, int y, int disposalMethod, int delayTime)
+{
+return new ImageData(
+width, height, depth, palette, scanlinePad, data, maskPad, maskData,
+alphaData, alpha, transparentPixel, type, x, y, disposalMethod, delayTime);
+}
+ImageData colorMaskImage(int pixel) {
+ImageData mask = new ImageData(width, height, 1, bwPalette(),
+2, null, 0, null, null, -1, -1, DWT.IMAGE_UNDEFINED,
+0, 0, 0, 0);
+int[] row = new int[width];
+for (int y = 0; y < height; y++) {
+getPixels(0, y, width, row, 0);
+for (int i = 0; i < width; i++) {
+if (pixel !is -1 && row[i] is pixel) {
+row[i] = 0;
+} else {
+row[i] = 1;
+}
+}
+mask.setPixels(0, y, width, row, 0);
+}
+return mask;
+}
+static byte[] checkData(byte [] data) {
+if (data is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+return data;
+}
+/**
+* Returns a new instance of the same class as the receiver,
+* whose slots have been filled in with <em>copies</em> of
+* the values in the slots of the receiver. That is, the
+* returned object is a <em>deep copy</em> of the receiver.
+*
+* @return a copy of the receiver.
+*/
+public Object clone() {
+byte[] cloneData = new byte[data.length];
+System.arraycopy(data, 0, cloneData, 0, data.length);
+byte[] cloneMaskData = null;
+if (maskData !is null) {
+cloneMaskData = new byte[maskData.length];
+System.arraycopy(maskData, 0, cloneMaskData, 0, maskData.length);
+}
+byte[] cloneAlphaData = null;
+if (alphaData !is null) {
+cloneAlphaData = new byte[alphaData.length];
+System.arraycopy(alphaData, 0, cloneAlphaData, 0, alphaData.length);
+}
+return new ImageData(
+width,
+height,
+depth,
+palette,
+scanlinePad,
+cloneData,
+maskPad,
+cloneMaskData,
+cloneAlphaData,
+alpha,
+transparentPixel,
+type,
+x,
+y,
+disposalMethod,
+delayTime);
+}
+/**
+* Returns the alpha value at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's alpha data.
+*
+* @param x the x coordinate of the pixel to get the alpha value of
+* @param y the y coordinate of the pixel to get the alpha value of
+* @return the alpha value at the given coordinates
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if either argument is out of range</li>
+* </ul>
+*/
+public int getAlpha(int x, int y) {
+if (x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (alphaData is null) return 255;
+return alphaData[y * width + x] & 0xFF;
+}
+/**
+* Returns <code>getWidth</code> alpha values starting at offset
+* <code>x</code> in scanline <code>y</code> in the receiver's alpha
+* data starting at <code>startIndex</code>.
+*
+* @param x the x position of the pixel to begin getting alpha values
+* @param y the y position of the pixel to begin getting alpha values
+* @param getWidth the width of the data to get
+* @param alphas the buffer in which to put the alpha values
+* @param startIndex the offset into the image to begin getting alpha values
+*
+* @exception IndexOutOfBoundsException if getWidth is too large
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if pixels is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*    <li>ERROR_INVALID_ARGUMENT - if getWidth is negative</li>
+* </ul>
+*/
+public void getAlphas(int x, int y, int getWidth, byte[] alphas, int startIndex) {
+if (alphas is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (getWidth < 0 || x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (getWidth is 0) return;
+if (alphaData is null) {
+int endIndex = startIndex + getWidth;
+for (int i = startIndex; i < endIndex; i++) {
+alphas[i] = (byte)255;
+}
+return;
+}
+// may throw an IndexOutOfBoundsException
+System.arraycopy(alphaData, y * width + x, alphas, startIndex, getWidth);
+}
+/**
+* Returns the pixel value at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's data.
+*
+* @param x the x position of the pixel to get
+* @param y the y position of the pixel to get
+* @return the pixel at the given coordinates
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if either argument is out of bounds</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_UNSUPPORTED_DEPTH if the depth is not one of 1, 2, 4, 8, 16, 24 or 32</li>
+* </ul>
+*/
+public int getPixel(int x, int y) {
+if (x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+int index;
+int theByte;
+int mask;
+switch (depth) {
+case 32:
+index = (y * bytesPerLine) + (x * 4);
+return ((data[index] & 0xFF) << 24) + ((data[index+1] & 0xFF) << 16) +
+((data[index+2] & 0xFF) << 8) + (data[index+3] & 0xFF);
+case 24:
+index = (y * bytesPerLine) + (x * 3);
+return ((data[index] & 0xFF) << 16) + ((data[index+1] & 0xFF) << 8) +
+(data[index+2] & 0xFF);
+case 16:
+index = (y * bytesPerLine) + (x * 2);
+return ((data[index+1] & 0xFF) << 8) + (data[index] & 0xFF);
+case 8:
+index = (y * bytesPerLine) + x ;
+return data[index] & 0xFF;
+case 4:
+index = (y * bytesPerLine) + (x >> 1);
+theByte = data[index] & 0xFF;
+if ((x & 0x1) is 0) {
+return theByte >> 4;
+} else {
+return theByte & 0x0F;
+}
+case 2:
+index = (y * bytesPerLine) + (x >> 2);
+theByte = data[index] & 0xFF;
+int offset = 3 - (x % 4);
+mask = 3 << (offset * 2);
+return (theByte & mask) >> (offset * 2);
+case 1:
+index = (y * bytesPerLine) + (x >> 3);
+theByte = data[index] & 0xFF;
+mask = 1 << (7 - (x & 0x7));
+if ((theByte & mask) is 0) {
+return 0;
+} else {
+return 1;
+}
+}
+DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
+return 0;
+}
+/**
+* Returns <code>getWidth</code> pixel values starting at offset
+* <code>x</code> in scanline <code>y</code> in the receiver's
+* data starting at <code>startIndex</code>.
+*
+* @param x the x position of the first pixel to get
+* @param y the y position of the first pixel to get
+* @param getWidth the width of the data to get
+* @param pixels the buffer in which to put the pixels
+* @param startIndex the offset into the byte array to begin storing pixels
+*
+* @exception IndexOutOfBoundsException if getWidth is too large
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if pixels is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*    <li>ERROR_INVALID_ARGUMENT - if getWidth is negative</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_UNSUPPORTED_DEPTH - if the depth is not one of 1, 2, 4 or 8
+*        (For higher depths, use the int[] version of this method.)</li>
+* </ul>
+*/
+public void getPixels(int x, int y, int getWidth, byte[] pixels, int startIndex) {
+if (pixels is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (getWidth < 0 || x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (getWidth is 0) return;
+int index;
+int theByte;
+int mask = 0;
+int n = getWidth;
+int i = startIndex;
+int srcX = x, srcY = y;
+switch (depth) {
+case 8:
+index = (y * bytesPerLine) + x;
+for (int j = 0; j < getWidth; j++) {
+pixels[i] = data[index];
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+return;
+case 4:
+index = (y * bytesPerLine) + (x >> 1);
+if ((x & 0x1) is 1) {
+theByte = data[index] & 0xFF;
+pixels[i] = (byte)(theByte & 0x0F);
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+while (n > 1) {
+theByte = data[index] & 0xFF;
+pixels[i] = (byte)(theByte >> 4);
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+pixels[i] = (byte)(theByte & 0x0F);
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+}
+if (n > 0) {
+theByte = data[index] & 0xFF;
+pixels[i] = (byte)(theByte >> 4);
+}
+return;
+case 2:
+index = (y * bytesPerLine) + (x >> 2);
+theByte = data[index] & 0xFF;
+int offset;
+while (n > 0) {
+offset = 3 - (srcX % 4);
+mask = 3 << (offset * 2);
+pixels[i] = (byte)((theByte & mask) >> (offset * 2));
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+if (n > 0) theByte = data[index] & 0xFF;
+srcX = 0;
+} else {
+if (offset is 0) {
+index++;
+theByte = data[index] & 0xFF;
+}
+}
+}
+return;
+case 1:
+index = (y * bytesPerLine) + (x >> 3);
+theByte = data[index] & 0xFF;
+while (n > 0) {
+mask = 1 << (7 - (srcX & 0x7));
+if ((theByte & mask) is 0) {
+pixels[i] = 0;
+} else {
+pixels[i] = 1;
+}
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+if (n > 0) theByte = data[index] & 0xFF;
+srcX = 0;
+} else {
+if (mask is 1) {
+index++;
+if (n > 0) theByte = data[index] & 0xFF;
+}
+}
+}
+return;
+}
+DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
+}
+/**
+* Returns <code>getWidth</code> pixel values starting at offset
+* <code>x</code> in scanline <code>y</code> in the receiver's
+* data starting at <code>startIndex</code>.
+*
+* @param x the x position of the first pixel to get
+* @param y the y position of the first pixel to get
+* @param getWidth the width of the data to get
+* @param pixels the buffer in which to put the pixels
+* @param startIndex the offset into the buffer to begin storing pixels
+*
+* @exception IndexOutOfBoundsException if getWidth is too large
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if pixels is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*    <li>ERROR_INVALID_ARGUMENT - if getWidth is negative</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_UNSUPPORTED_DEPTH - if the depth is not one of 1, 2, 4, 8, 16, 24 or 32</li>
+* </ul>
+*/
+public void getPixels(int x, int y, int getWidth, int[] pixels, int startIndex) {
+if (pixels is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (getWidth < 0 || x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (getWidth is 0) return;
+int index;
+int theByte;
+int mask;
+int n = getWidth;
+int i = startIndex;
+int srcX = x, srcY = y;
+switch (depth) {
+case 32:
+index = (y * bytesPerLine) + (x * 4);
+i = startIndex;
+for (int j = 0; j < getWidth; j++) {
+pixels[i] = ((data[index] & 0xFF) << 24) | ((data[index+1] & 0xFF) << 16)
+| ((data[index+2] & 0xFF) << 8) | (data[index+3] & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index += 4;
+}
+}
+return;
+case 24:
+index = (y * bytesPerLine) + (x * 3);
+for (int j = 0; j < getWidth; j++) {
+pixels[i] = ((data[index] & 0xFF) << 16) | ((data[index+1] & 0xFF) << 8)
+| (data[index+2] & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index += 3;
+}
+}
+return;
+case 16:
+index = (y * bytesPerLine) + (x * 2);
+for (int j = 0; j < getWidth; j++) {
+pixels[i] = ((data[index+1] & 0xFF) << 8) + (data[index] & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index += 2;
+}
+}
+return;
+case 8:
+index = (y * bytesPerLine) + x;
+for (int j = 0; j < getWidth; j++) {
+pixels[i] = data[index] & 0xFF;
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+return;
+case 4:
+index = (y * bytesPerLine) + (x >> 1);
+if ((x & 0x1) is 1) {
+theByte = data[index] & 0xFF;
+pixels[i] = theByte & 0x0F;
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+while (n > 1) {
+theByte = data[index] & 0xFF;
+pixels[i] = theByte >> 4;
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+pixels[i] = theByte & 0x0F;
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+}
+if (n > 0) {
+theByte = data[index] & 0xFF;
+pixels[i] = theByte >> 4;
+}
+return;
+case 2:
+index = (y * bytesPerLine) + (x >> 2);
+theByte = data[index] & 0xFF;
+int offset;
+while (n > 0) {
+offset = 3 - (srcX % 4);
+mask = 3 << (offset * 2);
+pixels[i] = (byte)((theByte & mask) >> (offset * 2));
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+if (n > 0) theByte = data[index] & 0xFF;
+srcX = 0;
+} else {
+if (offset is 0) {
+index++;
+theByte = data[index] & 0xFF;
+}
+}
+}
+return;
+case 1:
+index = (y * bytesPerLine) + (x >> 3);
+theByte = data[index] & 0xFF;
+while (n > 0) {
+mask = 1 << (7 - (srcX & 0x7));
+if ((theByte & mask) is 0) {
+pixels[i] = 0;
+} else {
+pixels[i] = 1;
+}
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+if (n > 0) theByte = data[index] & 0xFF;
+srcX = 0;
+} else {
+if (mask is 1) {
+index++;
+if (n > 0) theByte = data[index] & 0xFF;
+}
+}
+}
+return;
+}
+DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
+}
+/**
+* Returns an array of <code>RGB</code>s which comprise the
+* indexed color table of the receiver, or null if the receiver
+* has a direct color model.
+*
+* @return the RGB values for the image or null if direct color
+*
+* @see PaletteData#getRGBs()
+*/
+public RGB[] getRGBs() {
+return palette.getRGBs();
+}
+/**
+* Returns an <code>ImageData</code> which specifies the
+* transparency mask information for the receiver. If the
+* receiver has no transparency or is not an icon, returns
+* an opaque mask.
+*
+* @return the transparency mask
+*/
+public ImageData getTransparencyMask() {
+if (getTransparencyType() is DWT.TRANSPARENCY_MASK) {
+return new ImageData(width, height, 1, bwPalette(), maskPad, maskData);
+} else {
+return colorMaskImage(transparentPixel);
+}
+}
+/**
+* Returns the image transparency type, which will be one of
+* <code>DWT.TRANSPARENCY_NONE</code>, <code>DWT.TRANSPARENCY_MASK</code>,
+* <code>DWT.TRANSPARENCY_PIXEL</code> or <code>DWT.TRANSPARENCY_ALPHA</code>.
+*
+* @return the receiver's transparency type
+*/
+public int getTransparencyType() {
+if (maskData !is null) return DWT.TRANSPARENCY_MASK;
+if (transparentPixel !is -1) return DWT.TRANSPARENCY_PIXEL;
+if (alphaData !is null) return DWT.TRANSPARENCY_ALPHA;
+return DWT.TRANSPARENCY_NONE;
+}
+/**
+* Returns the byte order of the receiver.
+*
+* @return MSB_FIRST or LSB_FIRST
+*/
+int getByteOrder() {
+return depth !is 16 ? MSB_FIRST : LSB_FIRST;
+}
+/**
+* Returns a copy of the receiver which has been stretched or
+* shrunk to the specified size. If either the width or height
+* is negative, the resulting image will be inverted in the
+* associated axis.
+*
+* @param width the width of the new ImageData
+* @param height the height of the new ImageData
+* @return a scaled copy of the image
+*/
+public ImageData scaledTo(int width, int height) {
+/* Create a destination image with no data */
+final bool flipX = (width < 0);
+if (flipX) width = - width;
+final bool flipY = (height < 0);
+if (flipY) height = - height;
+ImageData dest = new ImageData(
+width, height, depth, palette,
+scanlinePad, null, 0, null,
+null, -1, transparentPixel, type,
+x, y, disposalMethod, delayTime);
+/* Scale the image contents */
+if (palette.isDirect) blit(BLIT_SRC,
+this.data, this.depth, this.bytesPerLine, this.getByteOrder(), 0, 0, this.width, this.height, 0, 0, 0,
+ALPHA_OPAQUE, null, 0, 0, 0,
+dest.data, dest.depth, dest.bytesPerLine, dest.getByteOrder(), 0, 0, dest.width, dest.height, 0, 0, 0,
+flipX, flipY);
+else blit(BLIT_SRC,
+this.data, this.depth, this.bytesPerLine, this.getByteOrder(), 0, 0, this.width, this.height, null, null, null,
+ALPHA_OPAQUE, null, 0, 0, 0,
+dest.data, dest.depth, dest.bytesPerLine, dest.getByteOrder(), 0, 0, dest.width, dest.height, null, null, null,
+flipX, flipY);
+/* Scale the image mask or alpha */
+if (maskData !is null) {
+dest.maskPad = this.maskPad;
+int destBpl = (dest.width + 7) / 8;
+destBpl = (destBpl + (dest.maskPad - 1)) / dest.maskPad * dest.maskPad;
+dest.maskData = new byte[destBpl * dest.height];
+int srcBpl = (this.width + 7) / 8;
+srcBpl = (srcBpl + (this.maskPad - 1)) / this.maskPad * this.maskPad;
+blit(BLIT_SRC,
+this.maskData, 1, srcBpl, MSB_FIRST, 0, 0, this.width, this.height, null, null, null,
+ALPHA_OPAQUE, null, 0, 0, 0,
+dest.maskData, 1, destBpl, MSB_FIRST, 0, 0, dest.width, dest.height, null, null, null,
+flipX, flipY);
+} else if (alpha !is -1) {
+dest.alpha = this.alpha;
+} else if (alphaData !is null) {
+dest.alphaData = new byte[dest.width * dest.height];
+blit(BLIT_SRC,
+this.alphaData, 8, this.width, MSB_FIRST, 0, 0, this.width, this.height, null, null, null,
+ALPHA_OPAQUE, null, 0, 0, 0,
+dest.alphaData, 8, dest.width, MSB_FIRST, 0, 0, dest.width, dest.height, null, null, null,
+flipX, flipY);
+}
+return dest;
+}
+/**
+* Sets the alpha value at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's alpha data.
+*
+* @param x the x coordinate of the alpha value to set
+* @param y the y coordinate of the alpha value to set
+* @param alpha the value to set the alpha to
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*  </ul>
+*/
+public void setAlpha(int x, int y, int alpha) {
+if (x >= width || y >= height || x < 0 || y < 0 || alpha < 0 || alpha > 255)
+DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (alphaData is null) alphaData = new byte[width * height];
+alphaData[y * width + x] = (byte)alpha;
+}
+/**
+* Sets the alpha values starting at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's alpha data to the
+* values from the array <code>alphas</code> starting at
+* <code>startIndex</code>.
+*
+* @param x the x coordinate of the pixel to being setting the alpha values
+* @param y the y coordinate of the pixel to being setting the alpha values
+* @param putWidth the width of the alpha values to set
+* @param alphas the alpha values to set
+* @param startIndex the index at which to begin setting
+*
+* @exception IndexOutOfBoundsException if putWidth is too large
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if pixels is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*    <li>ERROR_INVALID_ARGUMENT - if putWidth is negative</li>
+* </ul>
+*/
+public void setAlphas(int x, int y, int putWidth, byte[] alphas, int startIndex) {
+if (alphas is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (putWidth < 0 || x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (putWidth is 0) return;
+if (alphaData is null) alphaData = new byte[width * height];
+// may throw an IndexOutOfBoundsException
+System.arraycopy(alphas, startIndex, alphaData, y * width + x, putWidth);
+}
+/**
+* Sets the pixel value at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's data.
+*
+* @param x the x coordinate of the pixel to set
+* @param y the y coordinate of the pixel to set
+* @param pixelValue the value to set the pixel to
+*
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_UNSUPPORTED_DEPTH if the depth is not one of 1, 2, 4, 8, 16, 24 or 32</li>
+* </ul>
+*/
+public void setPixel(int x, int y, int pixelValue) {
+if (x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+int index;
+byte theByte;
+int mask;
+switch (depth) {
+case 32:
+index = (y * bytesPerLine) + (x * 4);
+data[index]  = (byte)((pixelValue >> 24) & 0xFF);
+data[index + 1] = (byte)((pixelValue >> 16) & 0xFF);
+data[index + 2] = (byte)((pixelValue >> 8) & 0xFF);
+data[index + 3] = (byte)(pixelValue & 0xFF);
+return;
+case 24:
+index = (y * bytesPerLine) + (x * 3);
+data[index] = (byte)((pixelValue >> 16) & 0xFF);
+data[index + 1] = (byte)((pixelValue >> 8) & 0xFF);
+data[index + 2] = (byte)(pixelValue & 0xFF);
+return;
+case 16:
+index = (y * bytesPerLine) + (x * 2);
+data[index + 1] = (byte)((pixelValue >> 8) & 0xFF);
+data[index] = (byte)(pixelValue & 0xFF);
+return;
+case 8:
+index = (y * bytesPerLine) + x ;
+data[index] = (byte)(pixelValue & 0xFF);
+return;
+case 4:
+index = (y * bytesPerLine) + (x >> 1);
+if ((x & 0x1) is 0) {
+data[index] = (byte)((data[index] & 0x0F) | ((pixelValue & 0x0F) << 4));
+} else {
+data[index] = (byte)((data[index] & 0xF0) | (pixelValue & 0x0F));
+}
+return;
+case 2:
+index = (y * bytesPerLine) + (x >> 2);
+theByte = data[index];
+int offset = 3 - (x % 4);
+mask = 0xFF ^ (3 << (offset * 2));
+data[index] = (byte)((data[index] & mask) | (pixelValue << (offset * 2)));
+return;
+case 1:
+index = (y * bytesPerLine) + (x >> 3);
+theByte = data[index];
+mask = 1 << (7 - (x & 0x7));
+if ((pixelValue & 0x1) is 1) {
+data[index] = (byte)(theByte | mask);
+} else {
+data[index] = (byte)(theByte & (mask ^ -1));
+}
+return;
+}
+DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
+}
+/**
+* Sets the pixel values starting at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's data to the
+* values from the array <code>pixels</code> starting at
+* <code>startIndex</code>.
+*
+* @param x the x position of the pixel to set
+* @param y the y position of the pixel to set
+* @param putWidth the width of the pixels to set
+* @param pixels the pixels to set
+* @param startIndex the index at which to begin setting
+*
+* @exception IndexOutOfBoundsException if putWidth is too large
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if pixels is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*    <li>ERROR_INVALID_ARGUMENT - if putWidth is negative</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_UNSUPPORTED_DEPTH if the depth is not one of 1, 2, 4, 8
+*        (For higher depths, use the int[] version of this method.)</li>
+* </ul>
+*/
+public void setPixels(int x, int y, int putWidth, byte[] pixels, int startIndex) {
+if (pixels is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (putWidth < 0 || x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (putWidth is 0) return;
+int index;
+int theByte;
+int mask;
+int n = putWidth;
+int i = startIndex;
+int srcX = x, srcY = y;
+switch (depth) {
+case 8:
+index = (y * bytesPerLine) + x;
+for (int j = 0; j < putWidth; j++) {
+data[index] = (byte)(pixels[i] & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+return;
+case 4:
+index = (y * bytesPerLine) + (x >> 1);
+bool high = (x & 0x1) is 0;
+while (n > 0) {
+theByte = pixels[i] & 0x0F;
+if (high) {
+data[index] = (byte)((data[index] & 0x0F) | (theByte << 4));
+} else {
+data[index] = (byte)((data[index] & 0xF0) | theByte);
+}
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+high = true;
+srcX = 0;
+} else {
+if (!high) index++;
+high = !high;
+}
+}
+return;
+case 2:
+byte [] masks = { (byte)0xFC, (byte)0xF3, (byte)0xCF, (byte)0x3F };
+index = (y * bytesPerLine) + (x >> 2);
+int offset = 3 - (x % 4);
+while (n > 0) {
+theByte = pixels[i] & 0x3;
+data[index] = (byte)((data[index] & masks[offset]) | (theByte << (offset * 2)));
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+offset = 0;
+srcX = 0;
+} else {
+if (offset is 0) {
+index++;
+offset = 3;
+} else {
+offset--;
+}
+}
+}
+return;
+case 1:
+index = (y * bytesPerLine) + (x >> 3);
+while (n > 0) {
+mask = 1 << (7 - (srcX & 0x7));
+if ((pixels[i] & 0x1) is 1) {
+data[index] = (byte)((data[index] & 0xFF) | mask);
+} else {
+data[index] = (byte)((data[index] & 0xFF) & (mask ^ -1));
+}
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+if (mask is 1) {
+index++;
+}
+}
+}
+return;
+}
+DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
+}
+/**
+* Sets the pixel values starting at offset <code>x</code> in
+* scanline <code>y</code> in the receiver's data to the
+* values from the array <code>pixels</code> starting at
+* <code>startIndex</code>.
+*
+* @param x the x position of the pixel to set
+* @param y the y position of the pixel to set
+* @param putWidth the width of the pixels to set
+* @param pixels the pixels to set
+* @param startIndex the index at which to begin setting
+*
+* @exception IndexOutOfBoundsException if putWidth is too large
+* @exception IllegalArgumentException <ul>
+*    <li>ERROR_NULL_ARGUMENT - if pixels is null</li>
+*    <li>ERROR_INVALID_ARGUMENT - if x or y is out of bounds</li>
+*    <li>ERROR_INVALID_ARGUMENT - if putWidth is negative</li>
+* </ul>
+* @exception DWTException <ul>
+*    <li>ERROR_UNSUPPORTED_DEPTH if the depth is not one of 1, 2, 4, 8, 16, 24 or 32</li>
+* </ul>
+*/
+public void setPixels(int x, int y, int putWidth, int[] pixels, int startIndex) {
+if (pixels is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+if (putWidth < 0 || x >= width || y >= height || x < 0 || y < 0) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
+if (putWidth is 0) return;
+int index;
+int theByte;
+int mask;
+int n = putWidth;
+int i = startIndex;
+int pixel;
+int srcX = x, srcY = y;
+switch (depth) {
+case 32:
+index = (y * bytesPerLine) + (x * 4);
+for (int j = 0; j < putWidth; j++) {
+pixel = pixels[i];
+data[index] = (byte)((pixel >> 24) & 0xFF);
+data[index + 1] = (byte)((pixel >> 16) & 0xFF);
+data[index + 2] = (byte)((pixel >> 8) & 0xFF);
+data[index + 3] = (byte)(pixel & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index += 4;
+}
+}
+return;
+case 24:
+index = (y * bytesPerLine) + (x * 3);
+for (int j = 0; j < putWidth; j++) {
+pixel = pixels[i];
+data[index] = (byte)((pixel >> 16) & 0xFF);
+data[index + 1] = (byte)((pixel >> 8) & 0xFF);
+data[index + 2] = (byte)(pixel & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index += 3;
+}
+}
+return;
+case 16:
+index = (y * bytesPerLine) + (x * 2);
+for (int j = 0; j < putWidth; j++) {
+pixel = pixels[i];
+data[index] = (byte)(pixel & 0xFF);
+data[index + 1] = (byte)((pixel >> 8) & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index += 2;
+}
+}
+return;
+case 8:
+index = (y * bytesPerLine) + x;
+for (int j = 0; j < putWidth; j++) {
+data[index] = (byte)(pixels[i] & 0xFF);
+i++;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+index++;
+}
+}
+return;
+case 4:
+index = (y * bytesPerLine) + (x >> 1);
+bool high = (x & 0x1) is 0;
+while (n > 0) {
+theByte = pixels[i] & 0x0F;
+if (high) {
+data[index] = (byte)((data[index] & 0x0F) | (theByte << 4));
+} else {
+data[index] = (byte)((data[index] & 0xF0) | theByte);
+}
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+high = true;
+srcX = 0;
+} else {
+if (!high) index++;
+high = !high;
+}
+}
+return;
+case 2:
+byte [] masks = { (byte)0xFC, (byte)0xF3, (byte)0xCF, (byte)0x3F };
+index = (y * bytesPerLine) + (x >> 2);
+int offset = 3 - (x % 4);
+while (n > 0) {
+theByte = pixels[i] & 0x3;
+data[index] = (byte)((data[index] & masks[offset]) | (theByte << (offset * 2)));
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+offset = 3;
+srcX = 0;
+} else {
+if (offset is 0) {
+index++;
+offset = 3;
+} else {
+offset--;
+}
+}
+}
+return;
+case 1:
+index = (y * bytesPerLine) + (x >> 3);
+while (n > 0) {
+mask = 1 << (7 - (srcX & 0x7));
+if ((pixels[i] & 0x1) is 1) {
+data[index] = (byte)((data[index] & 0xFF) | mask);
+} else {
+data[index] = (byte)((data[index] & 0xFF) & (mask ^ -1));
+}
+i++;
+n--;
+srcX++;
+if (srcX >= width) {
+srcY++;
+index = srcY * bytesPerLine;
+srcX = 0;
+} else {
+if (mask is 1) {
+index++;
+}
+}
+}
+return;
+}
+DWT.error(DWT.ERROR_UNSUPPORTED_DEPTH);
+}
+/**
+* Returns a palette with 2 colors: black & white.
+*/
+static PaletteData bwPalette() {
+return new PaletteData(new RGB[] {new RGB(0, 0, 0), new RGB(255, 255, 255)});
+}
+/**
+* Gets the offset of the most significant bit for
+* the given mask.
+*/
+static int getMSBOffset(int mask) {
+for (int i = 31; i >= 0; i--) {
+if (((mask >> i) & 0x1) !is 0) return i + 1;
+}
+return 0;
+}
+/**
+* Finds the closest match.
+*/
+static int closestMatch(int depth, byte red, byte green, byte blue, int redMask, int greenMask, int blueMask, byte[] reds, byte[] greens, byte[] blues) {
+if (depth > 8) {
+int rshift = 32 - getMSBOffset(redMask);
+int gshift = 32 - getMSBOffset(greenMask);
+int bshift = 32 - getMSBOffset(blueMask);
+return (((red << 24) >>> rshift) & redMask) |
+(((green << 24) >>> gshift) & greenMask) |
+(((blue << 24) >>> bshift) & blueMask);
+}
+int r, g, b;
+int minDistance = 0x7fffffff;
+int nearestPixel = 0;
+int n = reds.length;
+for (int j = 0; j < n; j++) {
+r = (reds[j] & 0xFF) - (red & 0xFF);
+g = (greens[j] & 0xFF) - (green & 0xFF);
+b = (blues[j] & 0xFF) - (blue & 0xFF);
+int distance = r*r + g*g + b*b;
+if (distance < minDistance) {
+nearestPixel = j;
+if (distance is 0) break;
+minDistance = distance;
+}
+}
+return nearestPixel;
+}
+static final ImageData convertMask(ImageData mask) {
+if (mask.depth is 1) return mask;
+PaletteData palette = new PaletteData(new RGB[] {new RGB(0, 0, 0), new RGB(255,255,255)});
+ImageData newMask = new ImageData(mask.width, mask.height, 1, palette);
+/* Find index of black in mask palette */
+int blackIndex = 0;
+RGB[] rgbs = mask.getRGBs();
+if (rgbs !is null) {
+while (blackIndex < rgbs.length) {
+if (rgbs[blackIndex].equals(palette.colors[0])) break;
+blackIndex++;
+}
+}
+int[] pixels = new int[mask.width];
+for (int y = 0; y < mask.height; y++) {
+mask.getPixels(0, y, mask.width, pixels, 0);
+for (int i = 0; i < pixels.length; i++) {
+if (pixels[i] is blackIndex) {
+pixels[i] = 0;
+} else {
+pixels[i] = 1;
+}
+}
+newMask.setPixels(0, y, mask.width, pixels, 0);
+}
+return newMask;
+}
+static final byte[] convertPad(byte[] data, int width, int height, int depth, int pad, int newPad) {
+if (pad is newPad) return data;
+int stride = (width * depth + 7) / 8;
+int bpl = (stride + (pad - 1)) / pad * pad;
+int newBpl = (stride + (newPad - 1)) / newPad * newPad;
+byte[] newData = new byte[height * newBpl];
+int srcIndex = 0, destIndex = 0;
+for (int y = 0; y < height; y++) {
+System.arraycopy(data, srcIndex, newData, destIndex, stride);
+srcIndex += bpl;
+destIndex += newBpl;
+}
+return newData;
+}
+/**
+* Blit operation bits to be OR'ed together to specify the desired operation.
+*/
+static final int
+BLIT_SRC = 1,     // copy source directly, else applies logic operations
+BLIT_ALPHA = 2,   // enable alpha blending
+BLIT_DITHER = 4;  // enable dithering in low color modes
+/**
+* Alpha mode, values 0 - 255 specify global alpha level
+*/
+static final int
+ALPHA_OPAQUE = 255,           // Fully opaque (ignores any alpha data)
+ALPHA_TRANSPARENT = 0,        // Fully transparent (ignores any alpha data)
+ALPHA_CHANNEL_SEPARATE = -1,  // Use alpha channel from separate alphaData
+ALPHA_CHANNEL_SOURCE = -2,    // Use alpha channel embedded in sourceData
+ALPHA_MASK_UNPACKED = -3,     // Use transparency mask formed by bytes in alphaData (non-zero is opaque)
+ALPHA_MASK_PACKED = -4,       // Use transparency mask formed by packed bits in alphaData
+ALPHA_MASK_INDEX = -5,        // Consider source palette indices transparent if in alphaData array
+ALPHA_MASK_RGB = -6;          // Consider source RGBs transparent if in RGB888 format alphaData array
+/**
+* Byte and bit order constants.
+*/
+static final int LSB_FIRST = 0;
+static final int MSB_FIRST = 1;
+/**
+* Data types (internal)
+*/
+private static final int
+// direct / true color formats with arbitrary masks & shifts
+TYPE_GENERIC_8 = 0,
+TYPE_GENERIC_16_MSB = 1,
+TYPE_GENERIC_16_LSB = 2,
+TYPE_GENERIC_24 = 3,
+TYPE_GENERIC_32_MSB = 4,
+TYPE_GENERIC_32_LSB = 5,
+// palette indexed color formats
+TYPE_INDEX_8 = 6,
+TYPE_INDEX_4 = 7,
+TYPE_INDEX_2 = 8,
+TYPE_INDEX_1_MSB = 9,
+TYPE_INDEX_1_LSB = 10;
+/**
+* Blits a direct palette image into a direct palette image.
+* <p>
+* Note: When the source and destination depth, order and masks
+* are pairwise equal and the blitter operation is BLIT_SRC,
+* the masks are ignored.  Hence when not changing the image
+* data format, 0 may be specified for the masks.
+* </p>
+*
+* @param op the blitter operation: a combination of BLIT_xxx flags
+*        (see BLIT_xxx constants)
+* @param srcData the source byte array containing image data
+* @param srcDepth the source depth: one of 8, 16, 24, 32
+* @param srcStride the source number of bytes per line
+* @param srcOrder the source byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if srcDepth is not 16 or 32
+* @param srcX the top-left x-coord of the source blit region
+* @param srcY the top-left y-coord of the source blit region
+* @param srcWidth the width of the source blit region
+* @param srcHeight the height of the source blit region
+* @param srcRedMask the source red channel mask
+* @param srcGreenMask the source green channel mask
+* @param srcBlueMask the source blue channel mask
+* @param alphaMode the alpha blending or mask mode, may be
+*        an integer 0-255 for global alpha; ignored if BLIT_ALPHA
+*        not specified in the blitter operations
+*        (see ALPHA_MODE_xxx constants)
+* @param alphaData the alpha blending or mask data, varies depending
+*        on the value of alphaMode and sometimes ignored
+* @param alphaStride the alpha data number of bytes per line
+* @param alphaX the top-left x-coord of the alpha blit region
+* @param alphaY the top-left y-coord of the alpha blit region
+* @param destData the destination byte array containing image data
+* @param destDepth the destination depth: one of 8, 16, 24, 32
+* @param destStride the destination number of bytes per line
+* @param destOrder the destination byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if destDepth is not 16 or 32
+* @param destX the top-left x-coord of the destination blit region
+* @param destY the top-left y-coord of the destination blit region
+* @param destWidth the width of the destination blit region
+* @param destHeight the height of the destination blit region
+* @param destRedMask the destination red channel mask
+* @param destGreenMask the destination green channel mask
+* @param destBlueMask the destination blue channel mask
+* @param flipX if true the resulting image is flipped along the vertical axis
+* @param flipY if true the resulting image is flipped along the horizontal axis
+*/
+static void blit(int op,
+byte[] srcData, int srcDepth, int srcStride, int srcOrder,
+int srcX, int srcY, int srcWidth, int srcHeight,
+int srcRedMask, int srcGreenMask, int srcBlueMask,
+int alphaMode, byte[] alphaData, int alphaStride, int alphaX, int alphaY,
+byte[] destData, int destDepth, int destStride, int destOrder,
+int destX, int destY, int destWidth, int destHeight,
+int destRedMask, int destGreenMask, int destBlueMask,
+bool flipX, bool flipY) {
+if ((destWidth <= 0) || (destHeight <= 0) || (alphaMode is ALPHA_TRANSPARENT)) return;
+// these should be supplied as params later
+final int srcAlphaMask = 0, destAlphaMask = 0;
+/*** Prepare scaling data ***/
+final int dwm1 = destWidth - 1;
+final int sfxi = (dwm1 !is 0) ? (int)((((long)srcWidth << 16) - 1) / dwm1) : 0;
+final int dhm1 = destHeight - 1;
+final int sfyi = (dhm1 !is 0) ? (int)((((long)srcHeight << 16) - 1) / dhm1) : 0;
+/*** Prepare source-related data ***/
+final int sbpp, stype;
+switch (srcDepth) {
+case 8:
+sbpp = 1;
+stype = TYPE_GENERIC_8;
+break;
+case 16:
+sbpp = 2;
+stype = (srcOrder is MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+break;
+case 24:
+sbpp = 3;
+stype = TYPE_GENERIC_24;
+break;
+case 32:
+sbpp = 4;
+stype = (srcOrder is MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid source type");
+return;
+}
+int spr = srcY * srcStride + srcX * sbpp;
+/*** Prepare destination-related data ***/
+final int dbpp, dtype;
+switch (destDepth) {
+case 8:
+dbpp = 1;
+dtype = TYPE_GENERIC_8;
+break;
+case 16:
+dbpp = 2;
+dtype = (destOrder is MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+break;
+case 24:
+dbpp = 3;
+dtype = TYPE_GENERIC_24;
+break;
+case 32:
+dbpp = 4;
+dtype = (destOrder is MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid destination type");
+return;
+}
+int dpr = ((flipY) ? destY + dhm1 : destY) * destStride + ((flipX) ? destX + dwm1 : destX) * dbpp;
+final int dprxi = (flipX) ? -dbpp : dbpp;
+final int dpryi = (flipY) ? -destStride : destStride;
+/*** Prepare special processing data ***/
+int apr;
+if ((op & BLIT_ALPHA) !is 0) {
+switch (alphaMode) {
+case ALPHA_MASK_UNPACKED:
+case ALPHA_CHANNEL_SEPARATE:
+if (alphaData is null) alphaMode = 0x10000;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_PACKED:
+if (alphaData is null) alphaMode = 0x10000;
+alphaStride <<= 3;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_INDEX:
+//throw new IllegalArgumentException("Invalid alpha type");
+return;
+case ALPHA_MASK_RGB:
+if (alphaData is null) alphaMode = 0x10000;
+apr = 0;
+break;
+default:
+alphaMode = (alphaMode << 16) / 255; // prescale
+case ALPHA_CHANNEL_SOURCE:
+apr = 0;
+break;
+}
+} else {
+alphaMode = 0x10000;
+apr = 0;
+}
+/*** Blit ***/
+int dp = dpr;
+int sp = spr;
+if ((alphaMode is 0x10000) && (stype is dtype) &&
+(srcRedMask is destRedMask) && (srcGreenMask is destGreenMask) &&
+(srcBlueMask is destBlueMask) && (srcAlphaMask is destAlphaMask)) {
+/*** Fast blit (straight copy) ***/
+switch (sbpp) {
+case 1:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+destData[dp] = srcData[sp];
+sp += (sfx >>> 16);
+}
+}
+break;
+case 2:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+destData[dp] = srcData[sp];
+destData[dp + 1] = srcData[sp + 1];
+sp += (sfx >>> 16) * 2;
+}
+}
+break;
+case 3:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+destData[dp] = srcData[sp];
+destData[dp + 1] = srcData[sp + 1];
+destData[dp + 2] = srcData[sp + 2];
+sp += (sfx >>> 16) * 3;
+}
+}
+break;
+case 4:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+destData[dp] = srcData[sp];
+destData[dp + 1] = srcData[sp + 1];
+destData[dp + 2] = srcData[sp + 2];
+destData[dp + 3] = srcData[sp + 3];
+sp += (sfx >>> 16) * 4;
+}
+}
+break;
+}
+return;
+}
+/*** Comprehensive blit (apply transformations) ***/
+final int srcRedShift = getChannelShift(srcRedMask);
+final byte[] srcReds = ANY_TO_EIGHT[getChannelWidth(srcRedMask, srcRedShift)];
+final int srcGreenShift = getChannelShift(srcGreenMask);
+final byte[] srcGreens = ANY_TO_EIGHT[getChannelWidth(srcGreenMask, srcGreenShift)];
+final int srcBlueShift = getChannelShift(srcBlueMask);
+final byte[] srcBlues = ANY_TO_EIGHT[getChannelWidth(srcBlueMask, srcBlueShift)];
+final int srcAlphaShift = getChannelShift(srcAlphaMask);
+final byte[] srcAlphas = ANY_TO_EIGHT[getChannelWidth(srcAlphaMask, srcAlphaShift)];
+final int destRedShift = getChannelShift(destRedMask);
+final int destRedWidth = getChannelWidth(destRedMask, destRedShift);
+final byte[] destReds = ANY_TO_EIGHT[destRedWidth];
+final int destRedPreShift = 8 - destRedWidth;
+final int destGreenShift = getChannelShift(destGreenMask);
+final int destGreenWidth = getChannelWidth(destGreenMask, destGreenShift);
+final byte[] destGreens = ANY_TO_EIGHT[destGreenWidth];
+final int destGreenPreShift = 8 - destGreenWidth;
+final int destBlueShift = getChannelShift(destBlueMask);
+final int destBlueWidth = getChannelWidth(destBlueMask, destBlueShift);
+final byte[] destBlues = ANY_TO_EIGHT[destBlueWidth];
+final int destBluePreShift = 8 - destBlueWidth;
+final int destAlphaShift = getChannelShift(destAlphaMask);
+final int destAlphaWidth = getChannelWidth(destAlphaMask, destAlphaShift);
+final byte[] destAlphas = ANY_TO_EIGHT[destAlphaWidth];
+final int destAlphaPreShift = 8 - destAlphaWidth;
+int ap = apr, alpha = alphaMode;
+int r = 0, g = 0, b = 0, a = 0;
+int rq = 0, gq = 0, bq = 0, aq = 0;
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+sp = spr += (sfy >>> 16) * srcStride,
+ap = apr += (sfy >>> 16) * alphaStride,
+sfy = (sfy & 0xffff) + sfyi,
+dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+dp += dprxi,
+sfx = (sfx & 0xffff) + sfxi) {
+/*** READ NEXT PIXEL ***/
+switch (stype) {
+case TYPE_GENERIC_8: {
+final int data = srcData[sp] & 0xff;
+sp += (sfx >>> 16);
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_MSB: {
+final int data = ((srcData[sp] & 0xff) << 8) | (srcData[sp + 1] & 0xff);
+sp += (sfx >>> 16) * 2;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_LSB: {
+final int data = ((srcData[sp + 1] & 0xff) << 8) | (srcData[sp] & 0xff);
+sp += (sfx >>> 16) * 2;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_24: {
+final int data = (( ((srcData[sp] & 0xff) << 8) |
+(srcData[sp + 1] & 0xff)) << 8) |
+(srcData[sp + 2] & 0xff);
+sp += (sfx >>> 16) * 3;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_MSB: {
+final int data = (( (( ((srcData[sp] & 0xff) << 8) |
+(srcData[sp + 1] & 0xff)) << 8) |
+(srcData[sp + 2] & 0xff)) << 8) |
+(srcData[sp + 3] & 0xff);
+sp += (sfx >>> 16) * 4;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_LSB: {
+final int data = (( (( ((srcData[sp + 3] & 0xff) << 8) |
+(srcData[sp + 2] & 0xff)) << 8) |
+(srcData[sp + 1] & 0xff)) << 8) |
+(srcData[sp] & 0xff);
+sp += (sfx >>> 16) * 4;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+}
+/*** DO SPECIAL PROCESSING IF REQUIRED ***/
+switch (alphaMode) {
+case ALPHA_CHANNEL_SEPARATE:
+alpha = ((alphaData[ap] & 0xff) << 16) / 255;
+ap += (sfx >> 16);
+break;
+case ALPHA_CHANNEL_SOURCE:
+alpha = (a << 16) / 255;
+break;
+case ALPHA_MASK_UNPACKED:
+alpha = (alphaData[ap] !is 0) ? 0x10000 : 0;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_PACKED:
+alpha = (alphaData[ap >> 3] << ((ap & 7) + 9)) & 0x10000;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_RGB:
+alpha = 0x10000;
+for (int i = 0; i < alphaData.length; i += 3) {
+if ((r is alphaData[i]) && (g is alphaData[i + 1]) && (b is alphaData[i + 2])) {
+alpha = 0x0000;
+break;
+}
+}
+break;
+}
+if (alpha !is 0x10000) {
+if (alpha is 0x0000) continue;
+switch (dtype) {
+case TYPE_GENERIC_8: {
+final int data = destData[dp] & 0xff;
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_MSB: {
+final int data = ((destData[dp] & 0xff) << 8) | (destData[dp + 1] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_LSB: {
+final int data = ((destData[dp + 1] & 0xff) << 8) | (destData[dp] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_24: {
+final int data = (( ((destData[dp] & 0xff) << 8) |
+(destData[dp + 1] & 0xff)) << 8) |
+(destData[dp + 2] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_MSB: {
+final int data = (( (( ((destData[dp] & 0xff) << 8) |
+(destData[dp + 1] & 0xff)) << 8) |
+(destData[dp + 2] & 0xff)) << 8) |
+(destData[dp + 3] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_LSB: {
+final int data = (( (( ((destData[dp + 3] & 0xff) << 8) |
+(destData[dp + 2] & 0xff)) << 8) |
+(destData[dp + 1] & 0xff)) << 8) |
+(destData[dp] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+}
+// Perform alpha blending
+a = aq + ((a - aq) * alpha >> 16);
+r = rq + ((r - rq) * alpha >> 16);
+g = gq + ((g - gq) * alpha >> 16);
+b = bq + ((b - bq) * alpha >> 16);
+}
+/*** WRITE NEXT PIXEL ***/
+final int data =
+(r >>> destRedPreShift << destRedShift) |
+(g >>> destGreenPreShift << destGreenShift) |
+(b >>> destBluePreShift << destBlueShift) |
+(a >>> destAlphaPreShift << destAlphaShift);
+switch (dtype) {
+case TYPE_GENERIC_8: {
+destData[dp] = (byte) data;
+} break;
+case TYPE_GENERIC_16_MSB: {
+destData[dp] = (byte) (data >>> 8);
+destData[dp + 1] = (byte) (data & 0xff);
+} break;
+case TYPE_GENERIC_16_LSB: {
+destData[dp] = (byte) (data & 0xff);
+destData[dp + 1] = (byte) (data >>> 8);
+} break;
+case TYPE_GENERIC_24: {
+destData[dp] = (byte) (data >>> 16);
+destData[dp + 1] = (byte) (data >>> 8);
+destData[dp + 2] = (byte) (data & 0xff);
+} break;
+case TYPE_GENERIC_32_MSB: {
+destData[dp] = (byte) (data >>> 24);
+destData[dp + 1] = (byte) (data >>> 16);
+destData[dp + 2] = (byte) (data >>> 8);
+destData[dp + 3] = (byte) (data & 0xff);
+} break;
+case TYPE_GENERIC_32_LSB: {
+destData[dp] = (byte) (data & 0xff);
+destData[dp + 1] = (byte) (data >>> 8);
+destData[dp + 2] = (byte) (data >>> 16);
+destData[dp + 3] = (byte) (data >>> 24);
+} break;
+}
+}
+}
+}
+/**
+* Blits an index palette image into an index palette image.
+* <p>
+* Note: The source and destination red, green, and blue
+* arrays may be null if no alpha blending or dither is to be
+* performed.
+* </p>
+*
+* @param op the blitter operation: a combination of BLIT_xxx flags
+*        (see BLIT_xxx constants)
+* @param srcData the source byte array containing image data
+* @param srcDepth the source depth: one of 1, 2, 4, 8
+* @param srcStride the source number of bytes per line
+* @param srcOrder the source byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if srcDepth is not 1
+* @param srcX the top-left x-coord of the source blit region
+* @param srcY the top-left y-coord of the source blit region
+* @param srcWidth the width of the source blit region
+* @param srcHeight the height of the source blit region
+* @param srcReds the source palette red component intensities
+* @param srcGreens the source palette green component intensities
+* @param srcBlues the source palette blue component intensities
+* @param alphaMode the alpha blending or mask mode, may be
+*        an integer 0-255 for global alpha; ignored if BLIT_ALPHA
+*        not specified in the blitter operations
+*        (see ALPHA_MODE_xxx constants)
+* @param alphaData the alpha blending or mask data, varies depending
+*        on the value of alphaMode and sometimes ignored
+* @param alphaStride the alpha data number of bytes per line
+* @param alphaX the top-left x-coord of the alpha blit region
+* @param alphaY the top-left y-coord of the alpha blit region
+* @param destData the destination byte array containing image data
+* @param destDepth the destination depth: one of 1, 2, 4, 8
+* @param destStride the destination number of bytes per line
+* @param destOrder the destination byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if destDepth is not 1
+* @param destX the top-left x-coord of the destination blit region
+* @param destY the top-left y-coord of the destination blit region
+* @param destWidth the width of the destination blit region
+* @param destHeight the height of the destination blit region
+* @param destReds the destination palette red component intensities
+* @param destGreens the destination palette green component intensities
+* @param destBlues the destination palette blue component intensities
+* @param flipX if true the resulting image is flipped along the vertical axis
+* @param flipY if true the resulting image is flipped along the horizontal axis
+*/
+static void blit(int op,
+byte[] srcData, int srcDepth, int srcStride, int srcOrder,
+int srcX, int srcY, int srcWidth, int srcHeight,
+byte[] srcReds, byte[] srcGreens, byte[] srcBlues,
+int alphaMode, byte[] alphaData, int alphaStride, int alphaX, int alphaY,
+byte[] destData, int destDepth, int destStride, int destOrder,
+int destX, int destY, int destWidth, int destHeight,
+byte[] destReds, byte[] destGreens, byte[] destBlues,
+bool flipX, bool flipY) {
+if ((destWidth <= 0) || (destHeight <= 0) || (alphaMode is ALPHA_TRANSPARENT)) return;
+/*** Prepare scaling data ***/
+final int dwm1 = destWidth - 1;
+final int sfxi = (dwm1 !is 0) ? (int)((((long)srcWidth << 16) - 1) / dwm1) : 0;
+final int dhm1 = destHeight - 1;
+final int sfyi = (dhm1 !is 0) ? (int)((((long)srcHeight << 16) - 1) / dhm1) : 0;
+/*** Prepare source-related data ***/
+final int stype;
+switch (srcDepth) {
+case 8:
+stype = TYPE_INDEX_8;
+break;
+case 4:
+srcStride <<= 1;
+stype = TYPE_INDEX_4;
+break;
+case 2:
+srcStride <<= 2;
+stype = TYPE_INDEX_2;
+break;
+case 1:
+srcStride <<= 3;
+stype = (srcOrder is MSB_FIRST) ? TYPE_INDEX_1_MSB : TYPE_INDEX_1_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid source type");
+return;
+}
+int spr = srcY * srcStride + srcX;
+/*** Prepare destination-related data ***/
+final int dtype;
+switch (destDepth) {
+case 8:
+dtype = TYPE_INDEX_8;
+break;
+case 4:
+destStride <<= 1;
+dtype = TYPE_INDEX_4;
+break;
+case 2:
+destStride <<= 2;
+dtype = TYPE_INDEX_2;
+break;
+case 1:
+destStride <<= 3;
+dtype = (destOrder is MSB_FIRST) ? TYPE_INDEX_1_MSB : TYPE_INDEX_1_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid source type");
+return;
+}
+int dpr = ((flipY) ? destY + dhm1 : destY) * destStride + ((flipX) ? destX + dwm1 : destX);
+final int dprxi = (flipX) ? -1 : 1;
+final int dpryi = (flipY) ? -destStride : destStride;
+/*** Prepare special processing data ***/
+int apr;
+if ((op & BLIT_ALPHA) !is 0) {
+switch (alphaMode) {
+case ALPHA_MASK_UNPACKED:
+case ALPHA_CHANNEL_SEPARATE:
+if (alphaData is null) alphaMode = 0x10000;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_PACKED:
+if (alphaData is null) alphaMode = 0x10000;
+alphaStride <<= 3;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_INDEX:
+case ALPHA_MASK_RGB:
+if (alphaData is null) alphaMode = 0x10000;
+apr = 0;
+break;
+default:
+alphaMode = (alphaMode << 16) / 255; // prescale
+case ALPHA_CHANNEL_SOURCE:
+apr = 0;
+break;
+}
+} else {
+alphaMode = 0x10000;
+apr = 0;
+}
+final bool ditherEnabled = (op & BLIT_DITHER) !is 0;
+/*** Blit ***/
+int dp = dpr;
+int sp = spr;
+int ap = apr;
+int destPaletteSize = 1 << destDepth;
+if ((destReds !is null) && (destReds.length < destPaletteSize)) destPaletteSize = destReds.length;
+byte[] paletteMapping = null;
+bool isExactPaletteMapping = true;
+switch (alphaMode) {
+case 0x10000:
+/*** If the palettes and formats are equivalent use a one-to-one mapping ***/
+if ((stype is dtype) &&
+(srcReds is destReds) && (srcGreens is destGreens) && (srcBlues is destBlues)) {
+paletteMapping = ONE_TO_ONE_MAPPING;
+break;
+/*** If palettes have not been supplied, supply a suitable mapping ***/
+} else if ((srcReds is null) || (destReds is null)) {
+if (srcDepth <= destDepth) {
+paletteMapping = ONE_TO_ONE_MAPPING;
+} else {
+paletteMapping = new byte[1 << srcDepth];
+int mask = (0xff << destDepth) >>> 8;
+for (int i = 0; i < paletteMapping.length; ++i) paletteMapping[i] = (byte)(i & mask);
+}
+break;
+}
+case ALPHA_MASK_UNPACKED:
+case ALPHA_MASK_PACKED:
+case ALPHA_MASK_INDEX:
+case ALPHA_MASK_RGB:
+/*** Generate a palette mapping ***/
+int srcPaletteSize = 1 << srcDepth;
+paletteMapping = new byte[srcPaletteSize];
+if ((srcReds !is null) && (srcReds.length < srcPaletteSize)) srcPaletteSize = srcReds.length;
+for (int i = 0, r, g, b, index; i < srcPaletteSize; ++i) {
+r = srcReds[i] & 0xff;
+g = srcGreens[i] & 0xff;
+b = srcBlues[i] & 0xff;
+index = 0;
+int minDistance = 0x7fffffff;
+for (int j = 0, dr, dg, db, distance; j < destPaletteSize; ++j) {
+dr = (destReds[j] & 0xff) - r;
+dg = (destGreens[j] & 0xff) - g;
+db = (destBlues[j] & 0xff) - b;
+distance = dr * dr + dg * dg + db * db;
+if (distance < minDistance) {
+index = j;
+if (distance is 0) break;
+minDistance = distance;
+}
+}
+paletteMapping[i] = (byte)index;
+if (minDistance !is 0) isExactPaletteMapping = false;
+}
+break;
+}
+if ((paletteMapping !is null) && (isExactPaletteMapping || ! ditherEnabled)) {
+if ((stype is dtype) && (alphaMode is 0x10000)) {
+/*** Fast blit (copy w/ mapping) ***/
+switch (stype) {
+case TYPE_INDEX_8:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+destData[dp] = paletteMapping[srcData[sp] & 0xff];
+sp += (sfx >>> 16);
+}
+}
+break;
+case TYPE_INDEX_4:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+final int v;
+if ((sp & 1) !is 0) v = paletteMapping[srcData[sp >> 1] & 0x0f];
+else v = (srcData[sp >> 1] >>> 4) & 0x0f;
+sp += (sfx >>> 16);
+if ((dp & 1) !is 0) destData[dp >> 1] = (byte)((destData[dp >> 1] & 0xf0) | v);
+else destData[dp >> 1] = (byte)((destData[dp >> 1] & 0x0f) | (v << 4));
+}
+}
+break;
+case TYPE_INDEX_2:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+final int index = paletteMapping[(srcData[sp >> 2] >>> (6 - (sp & 3) * 2)) & 0x03];
+sp += (sfx >>> 16);
+final int shift = 6 - (dp & 3) * 2;
+destData[dp >> 2] = (byte)(destData[dp >> 2] & ~(0x03 << shift) | (index << shift));
+}
+}
+break;
+case TYPE_INDEX_1_MSB:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+final int index = paletteMapping[(srcData[sp >> 3] >>> (7 - (sp & 7))) & 0x01];
+sp += (sfx >>> 16);
+final int shift = 7 - (dp & 7);
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (index << shift));
+}
+}
+break;
+case TYPE_INDEX_1_LSB:
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+final int index = paletteMapping[(srcData[sp >> 3] >>> (sp & 7)) & 0x01];
+sp += (sfx >>> 16);
+final int shift = dp & 7;
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (index << shift));
+}
+}
+break;
+}
+} else {
+/*** Convert between indexed modes using mapping and mask ***/
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+sp = spr += (sfy >>> 16) * srcStride,
+sfy = (sfy & 0xffff) + sfyi,
+dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+dp += dprxi,
+sfx = (sfx & 0xffff) + sfxi) {
+int index;
+/*** READ NEXT PIXEL ***/
+switch (stype) {
+case TYPE_INDEX_8:
+index = srcData[sp] & 0xff;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_4:
+if ((sp & 1) !is 0) index = srcData[sp >> 1] & 0x0f;
+else index = (srcData[sp >> 1] >>> 4) & 0x0f;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_2:
+index = (srcData[sp >> 2] >>> (6 - (sp & 3) * 2)) & 0x03;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_1_MSB:
+index = (srcData[sp >> 3] >>> (7 - (sp & 7))) & 0x01;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_1_LSB:
+index = (srcData[sp >> 3] >>> (sp & 7)) & 0x01;
+sp += (sfx >>> 16);
+break;
+default:
+return;
+}
+/*** APPLY MASK ***/
+switch (alphaMode) {
+case ALPHA_MASK_UNPACKED: {
+final byte mask = alphaData[ap];
+ap += (sfx >> 16);
+if (mask is 0) continue;
+} break;
+case ALPHA_MASK_PACKED: {
+final int mask = alphaData[ap >> 3] & (1 << (ap & 7));
+ap += (sfx >> 16);
+if (mask is 0) continue;
+} break;
+case ALPHA_MASK_INDEX: {
+int i = 0;
+while (i < alphaData.length) {
+if (index is (alphaData[i] & 0xff)) break;
+}
+if (i < alphaData.length) continue;
+} break;
+case ALPHA_MASK_RGB: {
+final byte r = srcReds[index], g = srcGreens[index], b = srcBlues[index];
+int i = 0;
+while (i < alphaData.length) {
+if ((r is alphaData[i]) && (g is alphaData[i + 1]) && (b is alphaData[i + 2])) break;
+i += 3;
+}
+if (i < alphaData.length) continue;
+} break;
+}
+index = paletteMapping[index] & 0xff;
+/*** WRITE NEXT PIXEL ***/
+switch (dtype) {
+case TYPE_INDEX_8:
+destData[dp] = (byte) index;
+break;
+case TYPE_INDEX_4:
+if ((dp & 1) !is 0) destData[dp >> 1] = (byte)((destData[dp >> 1] & 0xf0) | index);
+else destData[dp >> 1] = (byte)((destData[dp >> 1] & 0x0f) | (index << 4));
+break;
+case TYPE_INDEX_2: {
+final int shift = 6 - (dp & 3) * 2;
+destData[dp >> 2] = (byte)(destData[dp >> 2] & ~(0x03 << shift) | (index << shift));
+} break;
+case TYPE_INDEX_1_MSB: {
+final int shift = 7 - (dp & 7);
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (index << shift));
+} break;
+case TYPE_INDEX_1_LSB: {
+final int shift = dp & 7;
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (index << shift));
+} break;
+}
+}
+}
+}
+return;
+}
+/*** Comprehensive blit (apply transformations) ***/
+int alpha = alphaMode;
+int index = 0;
+int indexq = 0;
+int lastindex = 0, lastr = -1, lastg = -1, lastb = -1;
+final int[] rerr, gerr, berr;
+if (ditherEnabled) {
+rerr = new int[destWidth + 2];
+gerr = new int[destWidth + 2];
+berr = new int[destWidth + 2];
+} else {
+rerr = null; gerr = null; berr = null;
+}
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+sp = spr += (sfy >>> 16) * srcStride,
+ap = apr += (sfy >>> 16) * alphaStride,
+sfy = (sfy & 0xffff) + sfyi,
+dp = dpr += dpryi) {
+int lrerr = 0, lgerr = 0, lberr = 0;
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+dp += dprxi,
+sfx = (sfx & 0xffff) + sfxi) {
+/*** READ NEXT PIXEL ***/
+switch (stype) {
+case TYPE_INDEX_8:
+index = srcData[sp] & 0xff;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_4:
+if ((sp & 1) !is 0) index = srcData[sp >> 1] & 0x0f;
+else index = (srcData[sp >> 1] >>> 4) & 0x0f;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_2:
+index = (srcData[sp >> 2] >>> (6 - (sp & 3) * 2)) & 0x03;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_1_MSB:
+index = (srcData[sp >> 3] >>> (7 - (sp & 7))) & 0x01;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_1_LSB:
+index = (srcData[sp >> 3] >>> (sp & 7)) & 0x01;
+sp += (sfx >>> 16);
+break;
+}
+/*** DO SPECIAL PROCESSING IF REQUIRED ***/
+int r = srcReds[index] & 0xff, g = srcGreens[index] & 0xff, b = srcBlues[index] & 0xff;
+switch (alphaMode) {
+case ALPHA_CHANNEL_SEPARATE:
+alpha = ((alphaData[ap] & 0xff) << 16) / 255;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_UNPACKED:
+alpha = (alphaData[ap] !is 0) ? 0x10000 : 0;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_PACKED:
+alpha = (alphaData[ap >> 3] << ((ap & 7) + 9)) & 0x10000;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_INDEX: { // could speed up using binary search if we sorted the indices
+int i = 0;
+while (i < alphaData.length) {
+if (index is (alphaData[i] & 0xff)) break;
+}
+if (i < alphaData.length) continue;
+} break;
+case ALPHA_MASK_RGB: {
+int i = 0;
+while (i < alphaData.length) {
+if ((r is (alphaData[i] & 0xff)) &&
+(g is (alphaData[i + 1] & 0xff)) &&
+(b is (alphaData[i + 2] & 0xff))) break;
+i += 3;
+}
+if (i < alphaData.length) continue;
+} break;
+}
+if (alpha !is 0x10000) {
+if (alpha is 0x0000) continue;
+switch (dtype) {
+case TYPE_INDEX_8:
+indexq = destData[dp] & 0xff;
+break;
+case TYPE_INDEX_4:
+if ((dp & 1) !is 0) indexq = destData[dp >> 1] & 0x0f;
+else indexq = (destData[dp >> 1] >>> 4) & 0x0f;
+break;
+case TYPE_INDEX_2:
+indexq = (destData[dp >> 2] >>> (6 - (dp & 3) * 2)) & 0x03;
+break;
+case TYPE_INDEX_1_MSB:
+indexq = (destData[dp >> 3] >>> (7 - (dp & 7))) & 0x01;
+break;
+case TYPE_INDEX_1_LSB:
+indexq = (destData[dp >> 3] >>> (dp & 7)) & 0x01;
+break;
+}
+// Perform alpha blending
+final int rq = destReds[indexq] & 0xff;
+final int gq = destGreens[indexq] & 0xff;
+final int bq = destBlues[indexq] & 0xff;
+r = rq + ((r - rq) * alpha >> 16);
+g = gq + ((g - gq) * alpha >> 16);
+b = bq + ((b - bq) * alpha >> 16);
+}
+/*** MAP COLOR TO THE PALETTE ***/
+if (ditherEnabled) {
+// Floyd-Steinberg error diffusion
+r += rerr[dx] >> 4;
+if (r < 0) r = 0; else if (r > 255) r = 255;
+g += gerr[dx] >> 4;
+if (g < 0) g = 0; else if (g > 255) g = 255;
+b += berr[dx] >> 4;
+if (b < 0) b = 0; else if (b > 255) b = 255;
+rerr[dx] = lrerr;
+gerr[dx] = lgerr;
+berr[dx] = lberr;
+}
+if (r !is lastr || g !is lastg || b !is lastb) {
+// moving the variable declarations out seems to make the JDK JIT happier...
+for (int j = 0, dr, dg, db, distance, minDistance = 0x7fffffff; j < destPaletteSize; ++j) {
+dr = (destReds[j] & 0xff) - r;
+dg = (destGreens[j] & 0xff) - g;
+db = (destBlues[j] & 0xff) - b;
+distance = dr * dr + dg * dg + db * db;
+if (distance < minDistance) {
+lastindex = j;
+if (distance is 0) break;
+minDistance = distance;
+}
+}
+lastr = r; lastg = g; lastb = b;
+}
+if (ditherEnabled) {
+// Floyd-Steinberg error diffusion, cont'd...
+final int dxm1 = dx - 1, dxp1 = dx + 1;
+int acc;
+rerr[dxp1] += acc = (lrerr = r - (destReds[lastindex] & 0xff)) + lrerr + lrerr;
+rerr[dx] += acc += lrerr + lrerr;
+rerr[dxm1] += acc + lrerr + lrerr;
+gerr[dxp1] += acc = (lgerr = g - (destGreens[lastindex] & 0xff)) + lgerr + lgerr;
+gerr[dx] += acc += lgerr + lgerr;
+gerr[dxm1] += acc + lgerr + lgerr;
+berr[dxp1] += acc = (lberr = b - (destBlues[lastindex] & 0xff)) + lberr + lberr;
+berr[dx] += acc += lberr + lberr;
+berr[dxm1] += acc + lberr + lberr;
+}
+/*** WRITE NEXT PIXEL ***/
+switch (dtype) {
+case TYPE_INDEX_8:
+destData[dp] = (byte) lastindex;
+break;
+case TYPE_INDEX_4:
+if ((dp & 1) !is 0) destData[dp >> 1] = (byte)((destData[dp >> 1] & 0xf0) | lastindex);
+else destData[dp >> 1] = (byte)((destData[dp >> 1] & 0x0f) | (lastindex << 4));
+break;
+case TYPE_INDEX_2: {
+final int shift = 6 - (dp & 3) * 2;
+destData[dp >> 2] = (byte)(destData[dp >> 2] & ~(0x03 << shift) | (lastindex << shift));
+} break;
+case TYPE_INDEX_1_MSB: {
+final int shift = 7 - (dp & 7);
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (lastindex << shift));
+} break;
+case TYPE_INDEX_1_LSB: {
+final int shift = dp & 7;
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (lastindex << shift));
+} break;
+}
+}
+}
+}
+/**
+* Blits an index palette image into a direct palette image.
+* <p>
+* Note: The source and destination masks and palettes must
+* always be fully specified.
+* </p>
+*
+* @param op the blitter operation: a combination of BLIT_xxx flags
+*        (see BLIT_xxx constants)
+* @param srcData the source byte array containing image data
+* @param srcDepth the source depth: one of 1, 2, 4, 8
+* @param srcStride the source number of bytes per line
+* @param srcOrder the source byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if srcDepth is not 1
+* @param srcX the top-left x-coord of the source blit region
+* @param srcY the top-left y-coord of the source blit region
+* @param srcWidth the width of the source blit region
+* @param srcHeight the height of the source blit region
+* @param srcReds the source palette red component intensities
+* @param srcGreens the source palette green component intensities
+* @param srcBlues the source palette blue component intensities
+* @param alphaMode the alpha blending or mask mode, may be
+*        an integer 0-255 for global alpha; ignored if BLIT_ALPHA
+*        not specified in the blitter operations
+*        (see ALPHA_MODE_xxx constants)
+* @param alphaData the alpha blending or mask data, varies depending
+*        on the value of alphaMode and sometimes ignored
+* @param alphaStride the alpha data number of bytes per line
+* @param alphaX the top-left x-coord of the alpha blit region
+* @param alphaY the top-left y-coord of the alpha blit region
+* @param destData the destination byte array containing image data
+* @param destDepth the destination depth: one of 8, 16, 24, 32
+* @param destStride the destination number of bytes per line
+* @param destOrder the destination byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if destDepth is not 16 or 32
+* @param destX the top-left x-coord of the destination blit region
+* @param destY the top-left y-coord of the destination blit region
+* @param destWidth the width of the destination blit region
+* @param destHeight the height of the destination blit region
+* @param destRedMask the destination red channel mask
+* @param destGreenMask the destination green channel mask
+* @param destBlueMask the destination blue channel mask
+* @param flipX if true the resulting image is flipped along the vertical axis
+* @param flipY if true the resulting image is flipped along the horizontal axis
+*/
+static void blit(int op,
+byte[] srcData, int srcDepth, int srcStride, int srcOrder,
+int srcX, int srcY, int srcWidth, int srcHeight,
+byte[] srcReds, byte[] srcGreens, byte[] srcBlues,
+int alphaMode, byte[] alphaData, int alphaStride, int alphaX, int alphaY,
+byte[] destData, int destDepth, int destStride, int destOrder,
+int destX, int destY, int destWidth, int destHeight,
+int destRedMask, int destGreenMask, int destBlueMask,
+bool flipX, bool flipY) {
+if ((destWidth <= 0) || (destHeight <= 0) || (alphaMode is ALPHA_TRANSPARENT)) return;
+// these should be supplied as params later
+final int destAlphaMask = 0;
+/*** Prepare scaling data ***/
+final int dwm1 = destWidth - 1;
+final int sfxi = (dwm1 !is 0) ? (int)((((long)srcWidth << 16) - 1) / dwm1) : 0;
+final int dhm1 = destHeight - 1;
+final int sfyi = (dhm1 !is 0) ? (int)((((long)srcHeight << 16) - 1) / dhm1) : 0;
+/*** Prepare source-related data ***/
+final int stype;
+switch (srcDepth) {
+case 8:
+stype = TYPE_INDEX_8;
+break;
+case 4:
+srcStride <<= 1;
+stype = TYPE_INDEX_4;
+break;
+case 2:
+srcStride <<= 2;
+stype = TYPE_INDEX_2;
+break;
+case 1:
+srcStride <<= 3;
+stype = (srcOrder is MSB_FIRST) ? TYPE_INDEX_1_MSB : TYPE_INDEX_1_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid source type");
+return;
+}
+int spr = srcY * srcStride + srcX;
+/*** Prepare destination-related data ***/
+final int dbpp, dtype;
+switch (destDepth) {
+case 8:
+dbpp = 1;
+dtype = TYPE_GENERIC_8;
+break;
+case 16:
+dbpp = 2;
+dtype = (destOrder is MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+break;
+case 24:
+dbpp = 3;
+dtype = TYPE_GENERIC_24;
+break;
+case 32:
+dbpp = 4;
+dtype = (destOrder is MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid destination type");
+return;
+}
+int dpr = ((flipY) ? destY + dhm1 : destY) * destStride + ((flipX) ? destX + dwm1 : destX) * dbpp;
+final int dprxi = (flipX) ? -dbpp : dbpp;
+final int dpryi = (flipY) ? -destStride : destStride;
+/*** Prepare special processing data ***/
+int apr;
+if ((op & BLIT_ALPHA) !is 0) {
+switch (alphaMode) {
+case ALPHA_MASK_UNPACKED:
+case ALPHA_CHANNEL_SEPARATE:
+if (alphaData is null) alphaMode = 0x10000;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_PACKED:
+if (alphaData is null) alphaMode = 0x10000;
+alphaStride <<= 3;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_INDEX:
+case ALPHA_MASK_RGB:
+if (alphaData is null) alphaMode = 0x10000;
+apr = 0;
+break;
+default:
+alphaMode = (alphaMode << 16) / 255; // prescale
+case ALPHA_CHANNEL_SOURCE:
+apr = 0;
+break;
+}
+} else {
+alphaMode = 0x10000;
+apr = 0;
+}
+/*** Comprehensive blit (apply transformations) ***/
+final int destRedShift = getChannelShift(destRedMask);
+final int destRedWidth = getChannelWidth(destRedMask, destRedShift);
+final byte[] destReds = ANY_TO_EIGHT[destRedWidth];
+final int destRedPreShift = 8 - destRedWidth;
+final int destGreenShift = getChannelShift(destGreenMask);
+final int destGreenWidth = getChannelWidth(destGreenMask, destGreenShift);
+final byte[] destGreens = ANY_TO_EIGHT[destGreenWidth];
+final int destGreenPreShift = 8 - destGreenWidth;
+final int destBlueShift = getChannelShift(destBlueMask);
+final int destBlueWidth = getChannelWidth(destBlueMask, destBlueShift);
+final byte[] destBlues = ANY_TO_EIGHT[destBlueWidth];
+final int destBluePreShift = 8 - destBlueWidth;
+final int destAlphaShift = getChannelShift(destAlphaMask);
+final int destAlphaWidth = getChannelWidth(destAlphaMask, destAlphaShift);
+final byte[] destAlphas = ANY_TO_EIGHT[destAlphaWidth];
+final int destAlphaPreShift = 8 - destAlphaWidth;
+int dp = dpr;
+int sp = spr;
+int ap = apr, alpha = alphaMode;
+int r = 0, g = 0, b = 0, a = 0, index = 0;
+int rq = 0, gq = 0, bq = 0, aq = 0;
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+sp = spr += (sfy >>> 16) * srcStride,
+ap = apr += (sfy >>> 16) * alphaStride,
+sfy = (sfy & 0xffff) + sfyi,
+dp = dpr += dpryi) {
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+dp += dprxi,
+sfx = (sfx & 0xffff) + sfxi) {
+/*** READ NEXT PIXEL ***/
+switch (stype) {
+case TYPE_INDEX_8:
+index = srcData[sp] & 0xff;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_4:
+if ((sp & 1) !is 0) index = srcData[sp >> 1] & 0x0f;
+else index = (srcData[sp >> 1] >>> 4) & 0x0f;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_2:
+index = (srcData[sp >> 2] >>> (6 - (sp & 3) * 2)) & 0x03;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_1_MSB:
+index = (srcData[sp >> 3] >>> (7 - (sp & 7))) & 0x01;
+sp += (sfx >>> 16);
+break;
+case TYPE_INDEX_1_LSB:
+index = (srcData[sp >> 3] >>> (sp & 7)) & 0x01;
+sp += (sfx >>> 16);
+break;
+}
+/*** DO SPECIAL PROCESSING IF REQUIRED ***/
+r = srcReds[index] & 0xff;
+g = srcGreens[index] & 0xff;
+b = srcBlues[index] & 0xff;
+switch (alphaMode) {
+case ALPHA_CHANNEL_SEPARATE:
+alpha = ((alphaData[ap] & 0xff) << 16) / 255;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_UNPACKED:
+alpha = (alphaData[ap] !is 0) ? 0x10000 : 0;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_PACKED:
+alpha = (alphaData[ap >> 3] << ((ap & 7) + 9)) & 0x10000;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_INDEX: { // could speed up using binary search if we sorted the indices
+int i = 0;
+while (i < alphaData.length) {
+if (index is (alphaData[i] & 0xff)) break;
+}
+if (i < alphaData.length) continue;
+} break;
+case ALPHA_MASK_RGB: {
+int i = 0;
+while (i < alphaData.length) {
+if ((r is (alphaData[i] & 0xff)) &&
+(g is (alphaData[i + 1] & 0xff)) &&
+(b is (alphaData[i + 2] & 0xff))) break;
+i += 3;
+}
+if (i < alphaData.length) continue;
+} break;
+}
+if (alpha !is 0x10000) {
+if (alpha is 0x0000) continue;
+switch (dtype) {
+case TYPE_GENERIC_8: {
+final int data = destData[dp] & 0xff;
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_MSB: {
+final int data = ((destData[dp] & 0xff) << 8) | (destData[dp + 1] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_LSB: {
+final int data = ((destData[dp + 1] & 0xff) << 8) | (destData[dp] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_24: {
+final int data = (( ((destData[dp] & 0xff) << 8) |
+(destData[dp + 1] & 0xff)) << 8) |
+(destData[dp + 2] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_MSB: {
+final int data = (( (( ((destData[dp] & 0xff) << 8) |
+(destData[dp + 1] & 0xff)) << 8) |
+(destData[dp + 2] & 0xff)) << 8) |
+(destData[dp + 3] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_LSB: {
+final int data = (( (( ((destData[dp + 3] & 0xff) << 8) |
+(destData[dp + 2] & 0xff)) << 8) |
+(destData[dp + 1] & 0xff)) << 8) |
+(destData[dp] & 0xff);
+rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+} break;
+}
+// Perform alpha blending
+a = aq + ((a - aq) * alpha >> 16);
+r = rq + ((r - rq) * alpha >> 16);
+g = gq + ((g - gq) * alpha >> 16);
+b = bq + ((b - bq) * alpha >> 16);
+}
+/*** WRITE NEXT PIXEL ***/
+final int data =
+(r >>> destRedPreShift << destRedShift) |
+(g >>> destGreenPreShift << destGreenShift) |
+(b >>> destBluePreShift << destBlueShift) |
+(a >>> destAlphaPreShift << destAlphaShift);
+switch (dtype) {
+case TYPE_GENERIC_8: {
+destData[dp] = (byte) data;
+} break;
+case TYPE_GENERIC_16_MSB: {
+destData[dp] = (byte) (data >>> 8);
+destData[dp + 1] = (byte) (data & 0xff);
+} break;
+case TYPE_GENERIC_16_LSB: {
+destData[dp] = (byte) (data & 0xff);
+destData[dp + 1] = (byte) (data >>> 8);
+} break;
+case TYPE_GENERIC_24: {
+destData[dp] = (byte) (data >>> 16);
+destData[dp + 1] = (byte) (data >>> 8);
+destData[dp + 2] = (byte) (data & 0xff);
+} break;
+case TYPE_GENERIC_32_MSB: {
+destData[dp] = (byte) (data >>> 24);
+destData[dp + 1] = (byte) (data >>> 16);
+destData[dp + 2] = (byte) (data >>> 8);
+destData[dp + 3] = (byte) (data & 0xff);
+} break;
+case TYPE_GENERIC_32_LSB: {
+destData[dp] = (byte) (data & 0xff);
+destData[dp + 1] = (byte) (data >>> 8);
+destData[dp + 2] = (byte) (data >>> 16);
+destData[dp + 3] = (byte) (data >>> 24);
+} break;
+}
+}
+}
+}
+/**
+* Blits a direct palette image into an index palette image.
+* <p>
+* Note: The source and destination masks and palettes must
+* always be fully specified.
+* </p>
+*
+* @param op the blitter operation: a combination of BLIT_xxx flags
+*        (see BLIT_xxx constants)
+* @param srcData the source byte array containing image data
+* @param srcDepth the source depth: one of 8, 16, 24, 32
+* @param srcStride the source number of bytes per line
+* @param srcOrder the source byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if srcDepth is not 16 or 32
+* @param srcX the top-left x-coord of the source blit region
+* @param srcY the top-left y-coord of the source blit region
+* @param srcWidth the width of the source blit region
+* @param srcHeight the height of the source blit region
+* @param srcRedMask the source red channel mask
+* @param srcGreenMask the source green channel mask
+* @param srcBlueMask the source blue channel mask
+* @param alphaMode the alpha blending or mask mode, may be
+*        an integer 0-255 for global alpha; ignored if BLIT_ALPHA
+*        not specified in the blitter operations
+*        (see ALPHA_MODE_xxx constants)
+* @param alphaData the alpha blending or mask data, varies depending
+*        on the value of alphaMode and sometimes ignored
+* @param alphaStride the alpha data number of bytes per line
+* @param alphaX the top-left x-coord of the alpha blit region
+* @param alphaY the top-left y-coord of the alpha blit region
+* @param destData the destination byte array containing image data
+* @param destDepth the destination depth: one of 1, 2, 4, 8
+* @param destStride the destination number of bytes per line
+* @param destOrder the destination byte ordering: one of MSB_FIRST or LSB_FIRST;
+*        ignored if destDepth is not 1
+* @param destX the top-left x-coord of the destination blit region
+* @param destY the top-left y-coord of the destination blit region
+* @param destWidth the width of the destination blit region
+* @param destHeight the height of the destination blit region
+* @param destReds the destination palette red component intensities
+* @param destGreens the destination palette green component intensities
+* @param destBlues the destination palette blue component intensities
+* @param flipX if true the resulting image is flipped along the vertical axis
+* @param flipY if true the resulting image is flipped along the horizontal axis
+*/
+static void blit(int op,
+byte[] srcData, int srcDepth, int srcStride, int srcOrder,
+int srcX, int srcY, int srcWidth, int srcHeight,
+int srcRedMask, int srcGreenMask, int srcBlueMask,
+int alphaMode, byte[] alphaData, int alphaStride, int alphaX, int alphaY,
+byte[] destData, int destDepth, int destStride, int destOrder,
+int destX, int destY, int destWidth, int destHeight,
+byte[] destReds, byte[] destGreens, byte[] destBlues,
+bool flipX, bool flipY) {
+if ((destWidth <= 0) || (destHeight <= 0) || (alphaMode is ALPHA_TRANSPARENT)) return;
+// these should be supplied as params later
+final int srcAlphaMask = 0;
+/*** Prepare scaling data ***/
+final int dwm1 = destWidth - 1;
+final int sfxi = (dwm1 !is 0) ? (int)((((long)srcWidth << 16) - 1) / dwm1) : 0;
+final int dhm1 = destHeight - 1;
+final int sfyi = (dhm1 !is 0) ? (int)((((long)srcHeight << 16) - 1) / dhm1) : 0;
+/*** Prepare source-related data ***/
+final int sbpp, stype;
+switch (srcDepth) {
+case 8:
+sbpp = 1;
+stype = TYPE_GENERIC_8;
+break;
+case 16:
+sbpp = 2;
+stype = (srcOrder is MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+break;
+case 24:
+sbpp = 3;
+stype = TYPE_GENERIC_24;
+break;
+case 32:
+sbpp = 4;
+stype = (srcOrder is MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid source type");
+return;
+}
+int spr = srcY * srcStride + srcX * sbpp;
+/*** Prepare destination-related data ***/
+final int dtype;
+switch (destDepth) {
+case 8:
+dtype = TYPE_INDEX_8;
+break;
+case 4:
+destStride <<= 1;
+dtype = TYPE_INDEX_4;
+break;
+case 2:
+destStride <<= 2;
+dtype = TYPE_INDEX_2;
+break;
+case 1:
+destStride <<= 3;
+dtype = (destOrder is MSB_FIRST) ? TYPE_INDEX_1_MSB : TYPE_INDEX_1_LSB;
+break;
+default:
+//throw new IllegalArgumentException("Invalid source type");
+return;
+}
+int dpr = ((flipY) ? destY + dhm1 : destY) * destStride + ((flipX) ? destX + dwm1 : destX);
+final int dprxi = (flipX) ? -1 : 1;
+final int dpryi = (flipY) ? -destStride : destStride;
+/*** Prepare special processing data ***/
+int apr;
+if ((op & BLIT_ALPHA) !is 0) {
+switch (alphaMode) {
+case ALPHA_MASK_UNPACKED:
+case ALPHA_CHANNEL_SEPARATE:
+if (alphaData is null) alphaMode = 0x10000;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_PACKED:
+if (alphaData is null) alphaMode = 0x10000;
+alphaStride <<= 3;
+apr = alphaY * alphaStride + alphaX;
+break;
+case ALPHA_MASK_INDEX:
+//throw new IllegalArgumentException("Invalid alpha type");
+return;
+case ALPHA_MASK_RGB:
+if (alphaData is null) alphaMode = 0x10000;
+apr = 0;
+break;
+default:
+alphaMode = (alphaMode << 16) / 255; // prescale
+case ALPHA_CHANNEL_SOURCE:
+apr = 0;
+break;
+}
+} else {
+alphaMode = 0x10000;
+apr = 0;
+}
+final bool ditherEnabled = (op & BLIT_DITHER) !is 0;
+/*** Comprehensive blit (apply transformations) ***/
+final int srcRedShift = getChannelShift(srcRedMask);
+final byte[] srcReds = ANY_TO_EIGHT[getChannelWidth(srcRedMask, srcRedShift)];
+final int srcGreenShift = getChannelShift(srcGreenMask);
+final byte[] srcGreens = ANY_TO_EIGHT[getChannelWidth(srcGreenMask, srcGreenShift)];
+final int srcBlueShift = getChannelShift(srcBlueMask);
+final byte[] srcBlues = ANY_TO_EIGHT[getChannelWidth(srcBlueMask, srcBlueShift)];
+final int srcAlphaShift = getChannelShift(srcAlphaMask);
+final byte[] srcAlphas = ANY_TO_EIGHT[getChannelWidth(srcAlphaMask, srcAlphaShift)];
+int dp = dpr;
+int sp = spr;
+int ap = apr, alpha = alphaMode;
+int r = 0, g = 0, b = 0, a = 0;
+int indexq = 0;
+int lastindex = 0, lastr = -1, lastg = -1, lastb = -1;
+final int[] rerr, gerr, berr;
+int destPaletteSize = 1 << destDepth;
+if ((destReds !is null) && (destReds.length < destPaletteSize)) destPaletteSize = destReds.length;
+if (ditherEnabled) {
+rerr = new int[destWidth + 2];
+gerr = new int[destWidth + 2];
+berr = new int[destWidth + 2];
+} else {
+rerr = null; gerr = null; berr = null;
+}
+for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+sp = spr += (sfy >>> 16) * srcStride,
+ap = apr += (sfy >>> 16) * alphaStride,
+sfy = (sfy & 0xffff) + sfyi,
+dp = dpr += dpryi) {
+int lrerr = 0, lgerr = 0, lberr = 0;
+for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+dp += dprxi,
+sfx = (sfx & 0xffff) + sfxi) {
+/*** READ NEXT PIXEL ***/
+switch (stype) {
+case TYPE_GENERIC_8: {
+final int data = srcData[sp] & 0xff;
+sp += (sfx >>> 16);
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_MSB: {
+final int data = ((srcData[sp] & 0xff) << 8) | (srcData[sp + 1] & 0xff);
+sp += (sfx >>> 16) * 2;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_16_LSB: {
+final int data = ((srcData[sp + 1] & 0xff) << 8) | (srcData[sp] & 0xff);
+sp += (sfx >>> 16) * 2;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_24: {
+final int data = (( ((srcData[sp] & 0xff) << 8) |
+(srcData[sp + 1] & 0xff)) << 8) |
+(srcData[sp + 2] & 0xff);
+sp += (sfx >>> 16) * 3;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_MSB: {
+final int data = (( (( ((srcData[sp] & 0xff) << 8) |
+(srcData[sp + 1] & 0xff)) << 8) |
+(srcData[sp + 2] & 0xff)) << 8) |
+(srcData[sp + 3] & 0xff);
+sp += (sfx >>> 16) * 4;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+case TYPE_GENERIC_32_LSB: {
+final int data = (( (( ((srcData[sp + 3] & 0xff) << 8) |
+(srcData[sp + 2] & 0xff)) << 8) |
+(srcData[sp + 1] & 0xff)) << 8) |
+(srcData[sp] & 0xff);
+sp += (sfx >>> 16) * 4;
+r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+} break;
+}
+/*** DO SPECIAL PROCESSING IF REQUIRED ***/
+switch (alphaMode) {
+case ALPHA_CHANNEL_SEPARATE:
+alpha = ((alphaData[ap] & 0xff) << 16) / 255;
+ap += (sfx >> 16);
+break;
+case ALPHA_CHANNEL_SOURCE:
+alpha = (a << 16) / 255;
+break;
+case ALPHA_MASK_UNPACKED:
+alpha = (alphaData[ap] !is 0) ? 0x10000 : 0;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_PACKED:
+alpha = (alphaData[ap >> 3] << ((ap & 7) + 9)) & 0x10000;
+ap += (sfx >> 16);
+break;
+case ALPHA_MASK_RGB:
+alpha = 0x10000;
+for (int i = 0; i < alphaData.length; i += 3) {
+if ((r is alphaData[i]) && (g is alphaData[i + 1]) && (b is alphaData[i + 2])) {
+alpha = 0x0000;
+break;
+}
+}
+break;
+}
+if (alpha !is 0x10000) {
+if (alpha is 0x0000) continue;
+switch (dtype) {
+case TYPE_INDEX_8:
+indexq = destData[dp] & 0xff;
+break;
+case TYPE_INDEX_4:
+if ((dp & 1) !is 0) indexq = destData[dp >> 1] & 0x0f;
+else indexq = (destData[dp >> 1] >>> 4) & 0x0f;
+break;
+case TYPE_INDEX_2:
+indexq = (destData[dp >> 2] >>> (6 - (dp & 3) * 2)) & 0x03;
+break;
+case TYPE_INDEX_1_MSB:
+indexq = (destData[dp >> 3] >>> (7 - (dp & 7))) & 0x01;
+break;
+case TYPE_INDEX_1_LSB:
+indexq = (destData[dp >> 3] >>> (dp & 7)) & 0x01;
+break;
+}
+// Perform alpha blending
+final int rq = destReds[indexq] & 0xff;
+final int gq = destGreens[indexq] & 0xff;
+final int bq = destBlues[indexq] & 0xff;
+r = rq + ((r - rq) * alpha >> 16);
+g = gq + ((g - gq) * alpha >> 16);
+b = bq + ((b - bq) * alpha >> 16);
+}
+/*** MAP COLOR TO THE PALETTE ***/
+if (ditherEnabled) {
+// Floyd-Steinberg error diffusion
+r += rerr[dx] >> 4;
+if (r < 0) r = 0; else if (r > 255) r = 255;
+g += gerr[dx] >> 4;
+if (g < 0) g = 0; else if (g > 255) g = 255;
+b += berr[dx] >> 4;
+if (b < 0) b = 0; else if (b > 255) b = 255;
+rerr[dx] = lrerr;
+gerr[dx] = lgerr;
+berr[dx] = lberr;
+}
+if (r !is lastr || g !is lastg || b !is lastb) {
+// moving the variable declarations out seems to make the JDK JIT happier...
+for (int j = 0, dr, dg, db, distance, minDistance = 0x7fffffff; j < destPaletteSize; ++j) {
+dr = (destReds[j] & 0xff) - r;
+dg = (destGreens[j] & 0xff) - g;
+db = (destBlues[j] & 0xff) - b;
+distance = dr * dr + dg * dg + db * db;
+if (distance < minDistance) {
+lastindex = j;
+if (distance is 0) break;
+minDistance = distance;
+}
+}
+lastr = r; lastg = g; lastb = b;
+}
+if (ditherEnabled) {
+// Floyd-Steinberg error diffusion, cont'd...
+final int dxm1 = dx - 1, dxp1 = dx + 1;
+int acc;
+rerr[dxp1] += acc = (lrerr = r - (destReds[lastindex] & 0xff)) + lrerr + lrerr;
+rerr[dx] += acc += lrerr + lrerr;
+rerr[dxm1] += acc + lrerr + lrerr;
+gerr[dxp1] += acc = (lgerr = g - (destGreens[lastindex] & 0xff)) + lgerr + lgerr;
+gerr[dx] += acc += lgerr + lgerr;
+gerr[dxm1] += acc + lgerr + lgerr;
+berr[dxp1] += acc = (lberr = b - (destBlues[lastindex] & 0xff)) + lberr + lberr;
+berr[dx] += acc += lberr + lberr;
+berr[dxm1] += acc + lberr + lberr;
+}
+/*** WRITE NEXT PIXEL ***/
+switch (dtype) {
+case TYPE_INDEX_8:
+destData[dp] = (byte) lastindex;
+break;
+case TYPE_INDEX_4:
+if ((dp & 1) !is 0) destData[dp >> 1] = (byte)((destData[dp >> 1] & 0xf0) | lastindex);
+else destData[dp >> 1] = (byte)((destData[dp >> 1] & 0x0f) | (lastindex << 4));
+break;
+case TYPE_INDEX_2: {
+final int shift = 6 - (dp & 3) * 2;
+destData[dp >> 2] = (byte)(destData[dp >> 2] & ~(0x03 << shift) | (lastindex << shift));
+} break;
+case TYPE_INDEX_1_MSB: {
+final int shift = 7 - (dp & 7);
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (lastindex << shift));
+} break;
+case TYPE_INDEX_1_LSB: {
+final int shift = dp & 7;
+destData[dp >> 3] = (byte)(destData[dp >> 3] & ~(0x01 << shift) | (lastindex << shift));
+} break;
+}
+}
+}
+}
+/**
+* Computes the required channel shift from a mask.
+*/
+static int getChannelShift(int mask) {
+if (mask is 0) return 0;
+int i;
+for (i = 0; ((mask & 1) is 0) && (i < 32); ++i) {
+mask >>>= 1;
+}
+return i;
+}
+/**
+* Computes the required channel width (depth) from a mask.
+*/
+static int getChannelWidth(int mask, int shift) {
+if (mask is 0) return 0;
+int i;
+mask >>>= shift;
+for (i = shift; ((mask & 1) !is 0) && (i < 32); ++i) {
+mask >>>= 1;
+}
+return i - shift;
+}
+/**
+* Extracts a field from packed RGB data given a mask for that field.
+*/
+static byte getChannelField(int data, int mask) {
+final int shift = getChannelShift(mask);
+return ANY_TO_EIGHT[getChannelWidth(mask, shift)][(data & mask) >>> shift];
+}
+/**
+* Creates an ImageData containing one band's worth of a gradient filled
+* block.  If <code>vertical</code> is true, the band must be tiled
+* horizontally to fill a region, otherwise it must be tiled vertically.
+*
+* @param width the width of the region to be filled
+* @param height the height of the region to be filled
+* @param vertical if true sweeps from top to bottom, else
+*        sweeps from left to right
+* @param fromRGB the color to start with
+* @param toRGB the color to end with
+* @param redBits the number of significant red bits, 0 for palette modes
+* @param greenBits the number of significant green bits, 0 for palette modes
+* @param blueBits the number of significant blue bits, 0 for palette modes
+* @return the new ImageData
+*/
+static ImageData createGradientBand(
+int width, int height, bool vertical,
+RGB fromRGB, RGB toRGB,
+int redBits, int greenBits, int blueBits) {
+/* Gradients are drawn as tiled bands */
+final int bandWidth, bandHeight, bitmapDepth;
+final byte[] bitmapData;
+final PaletteData paletteData;
+/* Select an algorithm depending on the depth of the screen */
+if (redBits !is 0 && greenBits !is 0 && blueBits !is 0) {
+paletteData = new PaletteData(0x0000ff00, 0x00ff0000, 0xff000000);
+bitmapDepth = 32;
+if (redBits >= 8 && greenBits >= 8 && blueBits >= 8) {
+/* Precise color */
+final int steps;
+if (vertical) {
+bandWidth = 1;
+bandHeight = height;
+steps = bandHeight > 1 ? bandHeight - 1 : 1;
+} else {
+bandWidth = width;
+bandHeight = 1;
+steps = bandWidth > 1 ? bandWidth - 1 : 1;
+}
+final int bytesPerLine = bandWidth * 4;
+bitmapData = new byte[bandHeight * bytesPerLine];
+buildPreciseGradientChannel(fromRGB.blue, toRGB.blue, steps, bandWidth, bandHeight, vertical, bitmapData, 0, bytesPerLine);
+buildPreciseGradientChannel(fromRGB.green, toRGB.green, steps, bandWidth, bandHeight, vertical, bitmapData, 1, bytesPerLine);
+buildPreciseGradientChannel(fromRGB.red, toRGB.red, steps, bandWidth, bandHeight, vertical, bitmapData, 2, bytesPerLine);
+} else {
+/* Dithered color */
+final int steps;
+if (vertical) {
+bandWidth = (width < 8) ? width : 8;
+bandHeight = height;
+steps = bandHeight > 1 ? bandHeight - 1 : 1;
+} else {
+bandWidth = width;
+bandHeight = (height < 8) ? height : 8;
+steps = bandWidth > 1 ? bandWidth - 1 : 1;
+}
+final int bytesPerLine = bandWidth * 4;
+bitmapData = new byte[bandHeight * bytesPerLine];
+buildDitheredGradientChannel(fromRGB.blue, toRGB.blue, steps, bandWidth, bandHeight, vertical, bitmapData, 0, bytesPerLine, blueBits);
+buildDitheredGradientChannel(fromRGB.green, toRGB.green, steps, bandWidth, bandHeight, vertical, bitmapData, 1, bytesPerLine, greenBits);
+buildDitheredGradientChannel(fromRGB.red, toRGB.red, steps, bandWidth, bandHeight, vertical, bitmapData, 2, bytesPerLine, redBits);
+}
+} else {
+/* Dithered two tone */
+paletteData = new PaletteData(new RGB[] { fromRGB, toRGB });
+bitmapDepth = 8;
+final int blendi;
+if (vertical) {
+bandWidth = (width < 8) ? width : 8;
+bandHeight = height;
+blendi = (bandHeight > 1) ? 0x1040000 / (bandHeight - 1) + 1 : 1;
+} else {
+bandWidth = width;
+bandHeight = (height < 8) ? height : 8;
+blendi = (bandWidth > 1) ? 0x1040000 / (bandWidth - 1) + 1 : 1;
+}
+final int bytesPerLine = (bandWidth + 3) & -4;
+bitmapData = new byte[bandHeight * bytesPerLine];
+if (vertical) {
+for (int dy = 0, blend = 0, dp = 0; dy < bandHeight;
+++dy, blend += blendi, dp += bytesPerLine) {
+for (int dx = 0; dx < bandWidth; ++dx) {
+bitmapData[dp + dx] = (blend + DITHER_MATRIX[dy & 7][dx]) <
+0x1000000 ? (byte)0 : (byte)1;
+}
+}
+} else {
+for (int dx = 0, blend = 0; dx < bandWidth; ++dx, blend += blendi) {
+for (int dy = 0, dptr = dx; dy < bandHeight; ++dy, dptr += bytesPerLine) {
+bitmapData[dptr] = (blend + DITHER_MATRIX[dy][dx & 7]) <
+0x1000000 ? (byte)0 : (byte)1;
+}
+}
+}
+}
+return new ImageData(bandWidth, bandHeight, bitmapDepth, paletteData, 4, bitmapData);
+}
+/*
+* Fill in gradated values for a color channel
+*/
+static final void buildPreciseGradientChannel(int from, int to, int steps,
+int bandWidth, int bandHeight, bool vertical,
+byte[] bitmapData, int dp, int bytesPerLine) {
+int val = from << 16;
+final int inc = ((to << 16) - val) / steps + 1;
+if (vertical) {
+for (int dy = 0; dy < bandHeight; ++dy, dp += bytesPerLine) {
+bitmapData[dp] = (byte)(val >>> 16);
+val += inc;
+}
+} else {
+for (int dx = 0; dx < bandWidth; ++dx, dp += 4) {
+bitmapData[dp] = (byte)(val >>> 16);
+val += inc;
+}
+}
+}
+/*
+* Fill in dithered gradated values for a color channel
+*/
+static final void buildDitheredGradientChannel(int from, int to, int steps,
+int bandWidth, int bandHeight, bool vertical,
+byte[] bitmapData, int dp, int bytesPerLine, int bits) {
+final int mask = 0xff00 >>> bits;
+int val = from << 16;
+final int inc = ((to << 16) - val) / steps + 1;
+if (vertical) {
+for (int dy = 0; dy < bandHeight; ++dy, dp += bytesPerLine) {
+for (int dx = 0, dptr = dp; dx < bandWidth; ++dx, dptr += 4) {
+final int thresh = DITHER_MATRIX[dy & 7][dx] >>> bits;
+int temp = val + thresh;
+if (temp > 0xffffff) bitmapData[dptr] = -1;
+else bitmapData[dptr] = (byte)((temp >>> 16) & mask);
+}
+val += inc;
+}
+} else {
+for (int dx = 0; dx < bandWidth; ++dx, dp += 4) {
+for (int dy = 0, dptr = dp; dy < bandHeight; ++dy, dptr += bytesPerLine) {
+final int thresh = DITHER_MATRIX[dy][dx & 7] >>> bits;
+int temp = val + thresh;
+if (temp > 0xffffff) bitmapData[dptr] = -1;
+else bitmapData[dptr] = (byte)((temp >>> 16) & mask);
+}
+val += inc;
+}
+}
+}
+/**
+* Renders a gradient onto a GC.
+* <p>
+* This is a GC helper.
+* </p>
+*
+* @param gc the GC to render the gradient onto
+* @param device the device the GC belongs to
+* @param x the top-left x coordinate of the region to be filled
+* @param y the top-left y coordinate of the region to be filled
+* @param width the width of the region to be filled
+* @param height the height of the region to be filled
+* @param vertical if true sweeps from top to bottom, else
+*        sweeps from left to right
+* @param fromRGB the color to start with
+* @param toRGB the color to end with
+* @param redBits the number of significant red bits, 0 for palette modes
+* @param greenBits the number of significant green bits, 0 for palette modes
+* @param blueBits the number of significant blue bits, 0 for palette modes
+*/
+static void fillGradientRectangle(GC gc, Device device,
+int x, int y, int width, int height, bool vertical,
+RGB fromRGB, RGB toRGB,
+int redBits, int greenBits, int blueBits) {
+/* Create the bitmap and tile it */
+ImageData band = createGradientBand(width, height, vertical,
+fromRGB, toRGB, redBits, greenBits, blueBits);
+Image image = new Image(device, band);
+if ((band.width is 1) || (band.height is 1)) {
+gc.drawImage(image, 0, 0, band.width, band.height, x, y, width, height);
+} else {
+if (vertical) {
+for (int dx = 0; dx < width; dx += band.width) {
+int blitWidth = width - dx;
+if (blitWidth > band.width) blitWidth = band.width;
+gc.drawImage(image, 0, 0, blitWidth, band.height, dx + x, y, blitWidth, band.height);
+}
+} else {
+for (int dy = 0; dy < height; dy += band.height) {
+int blitHeight = height - dy;
+if (blitHeight > band.height) blitHeight = band.height;
+gc.drawImage(image, 0, 0, band.width, blitHeight, x, dy + y, band.width, blitHeight);
+}
+}
+}
+image.dispose();
+}
+}

Mercurial > projects > dwt-mac

comparison dwt/graphics/ImageData.d @ 0:380af2bdd8e5