bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/image/PngIhdrChunk.java - platform/eclipse.platform.swt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2006 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
  *******************************************************************************/
 package org.eclipse.swt.internal.image;


 import org.eclipse.swt.*;
 import org.eclipse.swt.graphics.*;

 class PngIhdrChunk extends PngChunk {
 	static final int IHDR_DATA_LENGTH = 13;

 	static final int WIDTH_DATA_OFFSET = DATA_OFFSET + 0;
 	static final int HEIGHT_DATA_OFFSET = DATA_OFFSET + 4;
 	static final int BIT_DEPTH_OFFSET = DATA_OFFSET + 8;
 	static final int COLOR_TYPE_OFFSET = DATA_OFFSET + 9;
 	static final int COMPRESSION_METHOD_OFFSET = DATA_OFFSET + 10;
 	static final int FILTER_METHOD_OFFSET = DATA_OFFSET + 11;
 	static final int INTERLACE_METHOD_OFFSET = DATA_OFFSET + 12;

 	static final byte COLOR_TYPE_GRAYSCALE = 0;
 	static final byte COLOR_TYPE_RGB = 2;
 	static final byte COLOR_TYPE_PALETTE = 3;
 	static final byte COLOR_TYPE_GRAYSCALE_WITH_ALPHA = 4;
 	static final byte COLOR_TYPE_RGB_WITH_ALPHA = 6;

 	static final int INTERLACE_METHOD_NONE = 0;
 	static final int INTERLACE_METHOD_ADAM7 = 1;

 	static final int FILTER_NONE = 0;
 	static final int FILTER_SUB = 1;
 	static final int FILTER_UP = 2;
 	static final int FILTER_AVERAGE = 3;
 	static final int FILTER_PAETH = 4;

 	static final byte[] ValidBitDepths = {1, 2, 4, 8, 16};
 	static final byte[] ValidColorTypes = {0, 2, 3, 4, 6};

 	int width, height;
 	byte bitDepth, colorType, compressionMethod, filterMethod, interlaceMethod;

 PngIhdrChunk(int width, int height, byte bitDepth, byte colorType, byte compressionMethod, byte filterMethod, byte interlaceMethod) {
 	super(IHDR_DATA_LENGTH);
 	setType(TYPE_IHDR);
 	setWidth(width);
 	setHeight(height);
 	setBitDepth(bitDepth);
 	setColorType(colorType);
 	setCompressionMethod(compressionMethod);
 	setFilterMethod(filterMethod);
 	setInterlaceMethod(interlaceMethod);
 	setCRC(computeCRC());
 }

 /**
  * Construct a PNGChunk using the reference bytes
  * given.
  */
 PngIhdrChunk(byte[] reference) {
 	super(reference);
 	if (reference.length <= IHDR_DATA_LENGTH) SWT.error(SWT.ERROR_INVALID_IMAGE);
 	width = getInt32(WIDTH_DATA_OFFSET);
 	height = getInt32(HEIGHT_DATA_OFFSET);
 	bitDepth = reference[BIT_DEPTH_OFFSET];
 	colorType = reference[COLOR_TYPE_OFFSET];
 	compressionMethod = reference[COMPRESSION_METHOD_OFFSET];
 	filterMethod = reference[FILTER_METHOD_OFFSET];
 	interlaceMethod = reference[INTERLACE_METHOD_OFFSET];
 }

 int getChunkType() {
 	return CHUNK_IHDR;
 }

 /**
  * Get the image's width in pixels.
  */
 int getWidth() {
 	return width;
 }

 /**
  * Set the image's width in pixels.
  */
 void setWidth(int value) {
 	setInt32(WIDTH_DATA_OFFSET, value);
 	width = value;
 }

 /**
  * Get the image's height in pixels.
  */
 int getHeight() {
 	return height;
 }

 /**
  * Set the image's height in pixels.
  */
 void setHeight(int value) {
 	setInt32(HEIGHT_DATA_OFFSET, value);
 	height = value;
 }

 /**
  * Get the image's bit depth.
  * This is limited to the values 1, 2, 4, 8, or 16.
  */
 byte getBitDepth() {
 	return bitDepth;
 }

 /**
  * Set the image's bit depth.
  * This is limited to the values 1, 2, 4, 8, or 16.
  */
 void setBitDepth(byte value) {
 	reference[BIT_DEPTH_OFFSET] = value;
 	bitDepth = value;
 }

 /**
  * Get the image's color type.
  * This is limited to the values:
  * 0 - Grayscale image.
  * 2 - RGB triple.
  * 3 - Palette.
  * 4 - Grayscale with Alpha channel.
  * 6 - RGB with Alpha channel.
  */
 byte getColorType() {
 	return colorType;
 }

 /**
  * Set the image's color type.
  * This is limited to the values:
  * 0 - Grayscale image.
  * 2 - RGB triple.
  * 3 - Palette.
  * 4 - Grayscale with Alpha channel.
  * 6 - RGB with Alpha channel.
  */
 void setColorType(byte value) {
 	reference[COLOR_TYPE_OFFSET] = value;
 	colorType = value;
 }

 /**
  * Get the image's compression method.
  * This value must be 0.
  */
 byte getCompressionMethod() {
 	return compressionMethod;
 }

 /**
  * Set the image's compression method.
  * This value must be 0.
  */
 void setCompressionMethod(byte value) {
 	reference[COMPRESSION_METHOD_OFFSET] = value;
 	compressionMethod = value;
 }

 /**
  * Get the image's filter method.
  * This value must be 0.
  */
 byte getFilterMethod() {
 	return filterMethod;
 }

 /**
  * Set the image's filter method.
  * This value must be 0.
  */
 void setFilterMethod(byte value) {
 	reference[FILTER_METHOD_OFFSET] = value;
 	filterMethod = value;
 }

 /**
  * Get the image's interlace method.
  * This value is limited to:
  * 0 - No interlacing used.
  * 1 - Adam7 interlacing used.
  */
 byte getInterlaceMethod() {
 	return interlaceMethod;
 }

 /**
  * Set the image's interlace method.
  * This value is limited to:
  * 0 - No interlacing used.
  * 1 - Adam7 interlacing used.
  */
 void setInterlaceMethod(byte value) {
 	reference[INTERLACE_METHOD_OFFSET] = value;
 	interlaceMethod = value;
 }

 /**
  * Answer whether the chunk is a valid IHDR chunk.
  */
 void validate(PngFileReadState readState, PngIhdrChunk headerChunk) {
 	// An IHDR chunk is invalid if any other chunk has
 	// been read.
 	if (readState.readIHDR
 		|| readState.readPLTE
 		|| readState.readIDAT
 		|| readState.readIEND)
 	{
 		SWT.error(SWT.ERROR_INVALID_IMAGE);
 	} else {
 		readState.readIHDR = true;
 	}

 	super.validate(readState, headerChunk);

 	if (length != IHDR_DATA_LENGTH) SWT.error(SWT.ERROR_INVALID_IMAGE);
 	if (compressionMethod != 0) SWT.error(SWT.ERROR_INVALID_IMAGE);
 	if (interlaceMethod != INTERLACE_METHOD_NONE &&
 		interlaceMethod != INTERLACE_METHOD_ADAM7) {
 			SWT.error(SWT.ERROR_INVALID_IMAGE);
 	}

 	boolean colorTypeIsValid = false;
 	for (int i = 0; i < ValidColorTypes.length; i++) {
 		if (ValidColorTypes[i] == colorType) {
 			colorTypeIsValid = true;
 			break;
 		}
 	}
 	if (!colorTypeIsValid) SWT.error(SWT.ERROR_INVALID_IMAGE);

 	boolean bitDepthIsValid = false;
 	for (int i = 0; i < ValidBitDepths.length; i++) {
 		if (ValidBitDepths[i] == bitDepth) {
 			bitDepthIsValid = true;
 			break;
 		}
 	}
 	if (!bitDepthIsValid) SWT.error(SWT.ERROR_INVALID_IMAGE);

 	if ((colorType == COLOR_TYPE_RGB
 		|| colorType == COLOR_TYPE_RGB_WITH_ALPHA
 		|| colorType == COLOR_TYPE_GRAYSCALE_WITH_ALPHA)
 		&& bitDepth < 8)
 	{
 			SWT.error(SWT.ERROR_INVALID_IMAGE);
 	}

 	if (colorType == COLOR_TYPE_PALETTE && bitDepth > 8) {
 		SWT.error(SWT.ERROR_INVALID_IMAGE);
 	}
 }

 String getColorTypeString() {
 	switch (colorType) {
 		case COLOR_TYPE_GRAYSCALE: 				return "Grayscale";
 		case COLOR_TYPE_RGB: 					return "RGB";
 		case COLOR_TYPE_PALETTE:				return "Palette";
 		case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:	return "Grayscale with Alpha";
 		case COLOR_TYPE_RGB_WITH_ALPHA:			return "RGB with Alpha";
 		default:								return "Unknown - " + colorType;
 	}
 }

 String getFilterMethodString() {
 	switch (filterMethod) {
 		case FILTER_NONE:		return "None";
 		case FILTER_SUB:		return "Sub";
 		case FILTER_UP:			return "Up";
 		case FILTER_AVERAGE:	return "Average";
 		case FILTER_PAETH:		return "Paeth";
 		default:				return "Unknown";
 	}
 }

 String getInterlaceMethodString() {
 	switch (interlaceMethod) {
 		case INTERLACE_METHOD_NONE: 	return "Not Interlaced";
 		case INTERLACE_METHOD_ADAM7:	return "Interlaced - ADAM7";
 		default:				return "Unknown";
 	}
 }

 void contributeToString(StringBuffer buffer) {
 	buffer.append("\n\tWidth: ");
 	buffer.append(width);
 	buffer.append("\n\tHeight: ");
 	buffer.append(height);
 	buffer.append("\n\tBit Depth: ");
 	buffer.append(bitDepth);
 	buffer.append("\n\tColor Type: ");
 	buffer.append(getColorTypeString());
 	buffer.append("\n\tCompression Method: ");
 	buffer.append(compressionMethod);
 	buffer.append("\n\tFilter Method: ");
 	buffer.append(getFilterMethodString());
 	buffer.append("\n\tInterlace Method: ");
 	buffer.append(getInterlaceMethodString());
 }

 boolean getMustHavePalette() {
 	return colorType == COLOR_TYPE_PALETTE;
 }

 boolean getCanHavePalette() {
 	return colorType != COLOR_TYPE_GRAYSCALE &&
 		colorType != COLOR_TYPE_GRAYSCALE_WITH_ALPHA;
 }

 /**
  * Answer the pixel size in bits based on the color type
  * and bit depth.
  */
 int getBitsPerPixel() {
 	switch (colorType) {
 		case COLOR_TYPE_RGB_WITH_ALPHA:
 			return 4 * bitDepth;
 		case COLOR_TYPE_RGB:
 			return 3 * bitDepth;
 		case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
 			return 2 * bitDepth;
 		case COLOR_TYPE_GRAYSCALE:
 		case COLOR_TYPE_PALETTE:
 			return bitDepth;
 		default:
 			SWT.error(SWT.ERROR_INVALID_IMAGE);
 			return 0;
 	}
 }

 /**
  * Answer the pixel size in bits based on the color type
  * and bit depth.
  */
 int getSwtBitsPerPixel() {
 	switch (colorType) {
 		case COLOR_TYPE_RGB_WITH_ALPHA:
 		case COLOR_TYPE_RGB:
 		case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
 			return 24;
 		case COLOR_TYPE_GRAYSCALE:
 		case COLOR_TYPE_PALETTE:
 			return Math.min(bitDepth, 8);
 		default:
 			SWT.error(SWT.ERROR_INVALID_IMAGE);
 			return 0;
 	}
 }

 int getFilterByteOffset() {
 	if (bitDepth < 8) return 1;
 	return getBitsPerPixel() / 8;
 }

 boolean usesDirectColor() {
 	switch (colorType) {
 		case COLOR_TYPE_GRAYSCALE:
 		case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
 		case COLOR_TYPE_RGB:
 		case COLOR_TYPE_RGB_WITH_ALPHA:
 			return true;
 		default:
 			return false;
 	}
 }

 PaletteData createGrayscalePalette() {
 	int depth = Math.min(bitDepth, 8);
 	int max = (1 << depth) - 1;
 	int delta = 255 / max;
 	int gray = 0;
 	RGB[] rgbs = new RGB[max + 1];
 	for (int i = 0; i <= max; i++) {
 		rgbs[i] = new RGB(gray, gray, gray);
 		gray += delta;
 	}
 	return new PaletteData(rgbs);
 }

 PaletteData getPaletteData() {
 	switch (colorType) {
 		case COLOR_TYPE_GRAYSCALE:
 			return createGrayscalePalette();
 		case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
 		case COLOR_TYPE_RGB:
 		case COLOR_TYPE_RGB_WITH_ALPHA:
 			return new PaletteData(0xFF0000, 0xFF00, 0xFF);
 		default:
 			return null;
 	}
 }


 }
	/*******************************************************************************
	* Copyright (c) 2000, 2006 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
	*******************************************************************************/
	package org.eclipse.swt.internal.image;


	import org.eclipse.swt.*;
	import org.eclipse.swt.graphics.*;

	class PngIhdrChunk extends PngChunk {
	static final int IHDR_DATA_LENGTH = 13;

	static final int WIDTH_DATA_OFFSET = DATA_OFFSET + 0;
	static final int HEIGHT_DATA_OFFSET = DATA_OFFSET + 4;
	static final int BIT_DEPTH_OFFSET = DATA_OFFSET + 8;
	static final int COLOR_TYPE_OFFSET = DATA_OFFSET + 9;
	static final int COMPRESSION_METHOD_OFFSET = DATA_OFFSET + 10;
	static final int FILTER_METHOD_OFFSET = DATA_OFFSET + 11;
	static final int INTERLACE_METHOD_OFFSET = DATA_OFFSET + 12;

	static final byte COLOR_TYPE_GRAYSCALE = 0;
	static final byte COLOR_TYPE_RGB = 2;
	static final byte COLOR_TYPE_PALETTE = 3;
	static final byte COLOR_TYPE_GRAYSCALE_WITH_ALPHA = 4;
	static final byte COLOR_TYPE_RGB_WITH_ALPHA = 6;

	static final int INTERLACE_METHOD_NONE = 0;
	static final int INTERLACE_METHOD_ADAM7 = 1;

	static final int FILTER_NONE = 0;
	static final int FILTER_SUB = 1;
	static final int FILTER_UP = 2;
	static final int FILTER_AVERAGE = 3;
	static final int FILTER_PAETH = 4;

	static final byte[] ValidBitDepths = {1, 2, 4, 8, 16};
	static final byte[] ValidColorTypes = {0, 2, 3, 4, 6};

	int width, height;
	byte bitDepth, colorType, compressionMethod, filterMethod, interlaceMethod;

	PngIhdrChunk(int width, int height, byte bitDepth, byte colorType, byte compressionMethod, byte filterMethod, byte interlaceMethod) {
	super(IHDR_DATA_LENGTH);
	setType(TYPE_IHDR);
	setWidth(width);
	setHeight(height);
	setBitDepth(bitDepth);
	setColorType(colorType);
	setCompressionMethod(compressionMethod);
	setFilterMethod(filterMethod);
	setInterlaceMethod(interlaceMethod);
	setCRC(computeCRC());
	}

	/**
	* Construct a PNGChunk using the reference bytes
	* given.
	*/
	PngIhdrChunk(byte[] reference) {
	super(reference);
	if (reference.length <= IHDR_DATA_LENGTH) SWT.error(SWT.ERROR_INVALID_IMAGE);
	width = getInt32(WIDTH_DATA_OFFSET);
	height = getInt32(HEIGHT_DATA_OFFSET);
	bitDepth = reference[BIT_DEPTH_OFFSET];
	colorType = reference[COLOR_TYPE_OFFSET];
	compressionMethod = reference[COMPRESSION_METHOD_OFFSET];
	filterMethod = reference[FILTER_METHOD_OFFSET];
	interlaceMethod = reference[INTERLACE_METHOD_OFFSET];
	}

	int getChunkType() {
	return CHUNK_IHDR;
	}

	/**
	* Get the image's width in pixels.
	*/
	int getWidth() {
	return width;
	}

	/**
	* Set the image's width in pixels.
	*/
	void setWidth(int value) {
	setInt32(WIDTH_DATA_OFFSET, value);
	width = value;
	}

	/**
	* Get the image's height in pixels.
	*/
	int getHeight() {
	return height;
	}

	/**
	* Set the image's height in pixels.
	*/
	void setHeight(int value) {
	setInt32(HEIGHT_DATA_OFFSET, value);
	height = value;
	}

	/**
	* Get the image's bit depth.
	* This is limited to the values 1, 2, 4, 8, or 16.
	*/
	byte getBitDepth() {
	return bitDepth;
	}

	/**
	* Set the image's bit depth.
	* This is limited to the values 1, 2, 4, 8, or 16.
	*/
	void setBitDepth(byte value) {
	reference[BIT_DEPTH_OFFSET] = value;
	bitDepth = value;
	}

	/**
	* Get the image's color type.
	* This is limited to the values:
	* 0 - Grayscale image.
	* 2 - RGB triple.
	* 3 - Palette.
	* 4 - Grayscale with Alpha channel.
	* 6 - RGB with Alpha channel.
	*/
	byte getColorType() {
	return colorType;
	}

	/**
	* Set the image's color type.
	* This is limited to the values:
	* 0 - Grayscale image.
	* 2 - RGB triple.
	* 3 - Palette.
	* 4 - Grayscale with Alpha channel.
	* 6 - RGB with Alpha channel.
	*/
	void setColorType(byte value) {
	reference[COLOR_TYPE_OFFSET] = value;
	colorType = value;
	}

	/**
	* Get the image's compression method.
	* This value must be 0.
	*/
	byte getCompressionMethod() {
	return compressionMethod;
	}

	/**
	* Set the image's compression method.
	* This value must be 0.
	*/
	void setCompressionMethod(byte value) {
	reference[COMPRESSION_METHOD_OFFSET] = value;
	compressionMethod = value;
	}

	/**
	* Get the image's filter method.
	* This value must be 0.
	*/
	byte getFilterMethod() {
	return filterMethod;
	}

	/**
	* Set the image's filter method.
	* This value must be 0.
	*/
	void setFilterMethod(byte value) {
	reference[FILTER_METHOD_OFFSET] = value;
	filterMethod = value;
	}

	/**
	* Get the image's interlace method.
	* This value is limited to:
	* 0 - No interlacing used.
	* 1 - Adam7 interlacing used.
	*/
	byte getInterlaceMethod() {
	return interlaceMethod;
	}

	/**
	* Set the image's interlace method.
	* This value is limited to:
	* 0 - No interlacing used.
	* 1 - Adam7 interlacing used.
	*/
	void setInterlaceMethod(byte value) {
	reference[INTERLACE_METHOD_OFFSET] = value;
	interlaceMethod = value;
	}

	/**
	* Answer whether the chunk is a valid IHDR chunk.
	*/
	void validate(PngFileReadState readState, PngIhdrChunk headerChunk) {
	// An IHDR chunk is invalid if any other chunk has
	// been read.
	if (readState.readIHDR
	\|\| readState.readPLTE
	\|\| readState.readIDAT
	\|\| readState.readIEND)
	{
	SWT.error(SWT.ERROR_INVALID_IMAGE);
	} else {
	readState.readIHDR = true;
	}

	super.validate(readState, headerChunk);

	if (length != IHDR_DATA_LENGTH) SWT.error(SWT.ERROR_INVALID_IMAGE);
	if (compressionMethod != 0) SWT.error(SWT.ERROR_INVALID_IMAGE);
	if (interlaceMethod != INTERLACE_METHOD_NONE &&
	interlaceMethod != INTERLACE_METHOD_ADAM7) {
	SWT.error(SWT.ERROR_INVALID_IMAGE);
	}

	boolean colorTypeIsValid = false;
	for (int i = 0; i < ValidColorTypes.length; i++) {
	if (ValidColorTypes[i] == colorType) {
	colorTypeIsValid = true;
	break;
	}
	}
	if (!colorTypeIsValid) SWT.error(SWT.ERROR_INVALID_IMAGE);

	boolean bitDepthIsValid = false;
	for (int i = 0; i < ValidBitDepths.length; i++) {
	if (ValidBitDepths[i] == bitDepth) {
	bitDepthIsValid = true;
	break;
	}
	}
	if (!bitDepthIsValid) SWT.error(SWT.ERROR_INVALID_IMAGE);

	if ((colorType == COLOR_TYPE_RGB
	\|\| colorType == COLOR_TYPE_RGB_WITH_ALPHA
	\|\| colorType == COLOR_TYPE_GRAYSCALE_WITH_ALPHA)
	&& bitDepth < 8)
	{
	SWT.error(SWT.ERROR_INVALID_IMAGE);
	}

	if (colorType == COLOR_TYPE_PALETTE && bitDepth > 8) {
	SWT.error(SWT.ERROR_INVALID_IMAGE);
	}
	}

	String getColorTypeString() {
	switch (colorType) {
	case COLOR_TYPE_GRAYSCALE: return "Grayscale";
	case COLOR_TYPE_RGB: return "RGB";
	case COLOR_TYPE_PALETTE: return "Palette";
	case COLOR_TYPE_GRAYSCALE_WITH_ALPHA: return "Grayscale with Alpha";
	case COLOR_TYPE_RGB_WITH_ALPHA: return "RGB with Alpha";
	default: return "Unknown - " + colorType;
	}
	}

	String getFilterMethodString() {
	switch (filterMethod) {
	case FILTER_NONE: return "None";
	case FILTER_SUB: return "Sub";
	case FILTER_UP: return "Up";
	case FILTER_AVERAGE: return "Average";
	case FILTER_PAETH: return "Paeth";
	default: return "Unknown";
	}
	}

	String getInterlaceMethodString() {
	switch (interlaceMethod) {
	case INTERLACE_METHOD_NONE: return "Not Interlaced";
	case INTERLACE_METHOD_ADAM7: return "Interlaced - ADAM7";
	default: return "Unknown";
	}
	}

	void contributeToString(StringBuffer buffer) {
	buffer.append("\n\tWidth: ");
	buffer.append(width);
	buffer.append("\n\tHeight: ");
	buffer.append(height);
	buffer.append("\n\tBit Depth: ");
	buffer.append(bitDepth);
	buffer.append("\n\tColor Type: ");
	buffer.append(getColorTypeString());
	buffer.append("\n\tCompression Method: ");
	buffer.append(compressionMethod);
	buffer.append("\n\tFilter Method: ");
	buffer.append(getFilterMethodString());
	buffer.append("\n\tInterlace Method: ");
	buffer.append(getInterlaceMethodString());
	}

	boolean getMustHavePalette() {
	return colorType == COLOR_TYPE_PALETTE;
	}

	boolean getCanHavePalette() {
	return colorType != COLOR_TYPE_GRAYSCALE &&
	colorType != COLOR_TYPE_GRAYSCALE_WITH_ALPHA;
	}

	/**
	* Answer the pixel size in bits based on the color type
	* and bit depth.
	*/
	int getBitsPerPixel() {
	switch (colorType) {
	case COLOR_TYPE_RGB_WITH_ALPHA:
	return 4 * bitDepth;
	case COLOR_TYPE_RGB:
	return 3 * bitDepth;
	case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
	return 2 * bitDepth;
	case COLOR_TYPE_GRAYSCALE:
	case COLOR_TYPE_PALETTE:
	return bitDepth;
	default:
	SWT.error(SWT.ERROR_INVALID_IMAGE);
	return 0;
	}
	}

	/**
	* Answer the pixel size in bits based on the color type
	* and bit depth.
	*/
	int getSwtBitsPerPixel() {
	switch (colorType) {
	case COLOR_TYPE_RGB_WITH_ALPHA:
	case COLOR_TYPE_RGB:
	case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
	return 24;
	case COLOR_TYPE_GRAYSCALE:
	case COLOR_TYPE_PALETTE:
	return Math.min(bitDepth, 8);
	default:
	SWT.error(SWT.ERROR_INVALID_IMAGE);
	return 0;
	}
	}

	int getFilterByteOffset() {
	if (bitDepth < 8) return 1;
	return getBitsPerPixel() / 8;
	}

	boolean usesDirectColor() {
	switch (colorType) {
	case COLOR_TYPE_GRAYSCALE:
	case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
	case COLOR_TYPE_RGB:
	case COLOR_TYPE_RGB_WITH_ALPHA:
	return true;
	default:
	return false;
	}
	}

	PaletteData createGrayscalePalette() {
	int depth = Math.min(bitDepth, 8);
	int max = (1 << depth) - 1;
	int delta = 255 / max;
	int gray = 0;
	RGB[] rgbs = new RGB[max + 1];
	for (int i = 0; i <= max; i++) {
	rgbs[i] = new RGB(gray, gray, gray);
	gray += delta;
	}
	return new PaletteData(rgbs);
	}

	PaletteData getPaletteData() {
	switch (colorType) {
	case COLOR_TYPE_GRAYSCALE:
	return createGrayscalePalette();
	case COLOR_TYPE_GRAYSCALE_WITH_ALPHA:
	case COLOR_TYPE_RGB:
	case COLOR_TYPE_RGB_WITH_ALPHA:
	return new PaletteData(0xFF0000, 0xFF00, 0xFF);
	default:
	return null;
	}
	}



	}