/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Igor V. Stolyarov
* @version $Revision$
*/
package java.awt.image;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The MultiPixelPackedSampleModel class represents image data with one band.
* This class packs multiple pixels with one sample in one data element and
* supports the following data types: DataBuffer.TYPE_BYTE,
* DataBuffer.TYPE_USHORT, or DataBuffer.TYPE_INT.
*
* @since Android 1.0
*/
public class MultiPixelPackedSampleModel extends SampleModel {
/**
* The pixel bit stride.
*/
private int pixelBitStride;
/**
* The scanline stride.
*/
private int scanlineStride;
/**
* The data bit offset.
*/
private int dataBitOffset;
/**
* The bit mask.
*/
private int bitMask;
/**
* The data element size.
*/
private int dataElementSize;
/**
* The pixels per data element.
*/
private int pixelsPerDataElement;
/**
* Instantiates a new MultiPixelPackedSampleModel with the specified
* parameters.
*
* @param dataType
* the data type of the samples.
* @param w
* the width of the image data.
* @param h
* the height of the image data.
* @param numberOfBits
* the number of bits per pixel.
* @param scanlineStride
* the scanline stride of the of the image data.
* @param dataBitOffset
* the array of the band offsets.
*/
public MultiPixelPackedSampleModel(int dataType, int w, int h, int numberOfBits,
int scanlineStride, int dataBitOffset) {
super(dataType, w, h, 1);
if (dataType != DataBuffer.TYPE_BYTE && dataType != DataBuffer.TYPE_USHORT
&& dataType != DataBuffer.TYPE_INT) {
// awt.61=Unsupported data type: {0}
throw new IllegalArgumentException(Messages.getString("awt.61", //$NON-NLS-1$
dataType));
}
this.scanlineStride = scanlineStride;
if (numberOfBits == 0) {
// awt.20C=Number of Bits equals to zero
throw new RasterFormatException(Messages.getString("awt.20C")); //$NON-NLS-1$
}
this.pixelBitStride = numberOfBits;
this.dataElementSize = DataBuffer.getDataTypeSize(dataType);
if (dataElementSize % pixelBitStride != 0) {
// awt.20D=The number of bits per pixel is not a power of 2 or
// pixels span data element boundaries
throw new RasterFormatException(Messages.getString("awt.20D")); //$NON-NLS-1$
}
if (dataBitOffset % numberOfBits != 0) {
// awt.20E=Data Bit offset is not a multiple of pixel bit stride
throw new RasterFormatException(Messages.getString("awt.20E")); //$NON-NLS-1$
}
this.dataBitOffset = dataBitOffset;
this.pixelsPerDataElement = dataElementSize / pixelBitStride;
this.bitMask = (1 << numberOfBits) - 1;
}
/**
* Instantiates a new MultiPixelPackedSampleModel with the specified
* parameters.
*
* @param dataType
* the data type of the samples.
* @param w
* the width of the image data.
* @param h
* the height of the image data.
* @param numberOfBits
* the number of bits per pixel.
*/
public MultiPixelPackedSampleModel(int dataType, int w, int h, int numberOfBits) {
this(dataType, w, h, numberOfBits,
(numberOfBits * w + DataBuffer.getDataTypeSize(dataType) - 1)
/ DataBuffer.getDataTypeSize(dataType), 0);
}
@Override
public Object getDataElements(int x, int y, Object obj, DataBuffer data) {
if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
// awt.63=Coordinates are not in bounds
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
}
switch (getTransferType()) {
case DataBuffer.TYPE_BYTE:
byte bdata[];
if (obj == null) {
bdata = new byte[1];
} else {
bdata = (byte[])obj;
}
bdata[0] = (byte)getSample(x, y, 0, data);
obj = bdata;
break;
case DataBuffer.TYPE_USHORT:
short sdata[];
if (obj == null) {
sdata = new short[1];
} else {
sdata = (short[])obj;
}
sdata[0] = (short)getSample(x, y, 0, data);
obj = sdata;
break;
case DataBuffer.TYPE_INT:
int idata[];
if (obj == null) {
idata = new int[1];
} else {
idata = (int[])obj;
}
idata[0] = getSample(x, y, 0, data);
obj = idata;
break;
}
return obj;
}
@Override
public void setDataElements(int x, int y, Object obj, DataBuffer data) {
setSample(x, y, obj, data, 1, 0);
}
/**
* Compares this MultiPixelPackedSampleModel object with the specified
* object.
*
* @param o
* the Object to be compared.
* @return true, if the object is a MultiPixelPackedSampleModel with the
* same data parameter values as this MultiPixelPackedSampleModel,
* false otherwise.
*/
@Override
public boolean equals(Object o) {
if ((o == null) || !(o instanceof MultiPixelPackedSampleModel)) {
return false;
}
MultiPixelPackedSampleModel model = (MultiPixelPackedSampleModel)o;
return this.width == model.width && this.height == model.height
&& this.numBands == model.numBands && this.dataType == model.dataType
&& this.pixelBitStride == model.pixelBitStride && this.bitMask == model.bitMask
&& this.pixelsPerDataElement == model.pixelsPerDataElement
&& this.dataElementSize == model.dataElementSize
&& this.dataBitOffset == model.dataBitOffset
&& this.scanlineStride == model.scanlineStride;
}
@Override
public SampleModel createSubsetSampleModel(int bands[]) {
if (bands != null && bands.length != 1) {
// awt.20F=Number of bands must be only 1
throw new RasterFormatException(Messages.getString("awt.20F")); //$NON-NLS-1$
}
return createCompatibleSampleModel(width, height);
}
@Override
public SampleModel createCompatibleSampleModel(int w, int h) {
return new MultiPixelPackedSampleModel(dataType, w, h, pixelBitStride);
}
@Override
public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
if (x < 0 || y < 0 || x >= this.width || y >= this.height) {
// awt.63=Coordinates are not in bounds
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
}
int pixel[];
if (iArray == null) {
pixel = new int[numBands];
} else {
pixel = iArray;
}
pixel[0] = getSample(x, y, 0, data);
return pixel;
}
@Override
public void setPixel(int x, int y, int iArray[], DataBuffer data) {
setSample(x, y, iArray, data, 2, 0);
}
@Override
public int getSample(int x, int y, int b, DataBuffer data) {
if (x < 0 || y < 0 || x >= this.width || y >= this.height || b != 0) {
// awt.63=Coordinates are not in bounds
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
}
int bitnum = dataBitOffset + x * pixelBitStride;
int elem = data.getElem(y * scanlineStride + bitnum / dataElementSize);
int shift = dataElementSize - (bitnum & (dataElementSize - 1)) - pixelBitStride;
return (elem >> shift) & bitMask;
}
@Override
public void setSample(int x, int y, int b, int s, DataBuffer data) {
if (b != 0) {
// awt.63=Coordinates are not in bounds
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
}
setSample(x, y, null, data, 3, s);
}
@Override
public DataBuffer createDataBuffer() {
DataBuffer dataBuffer = null;
int size = scanlineStride * height;
switch (dataType) {
case DataBuffer.TYPE_BYTE:
dataBuffer = new DataBufferByte(size + (dataBitOffset + 7) / 8);
break;
case DataBuffer.TYPE_USHORT:
dataBuffer = new DataBufferUShort(size + (dataBitOffset + 15) / 16);
break;
case DataBuffer.TYPE_INT:
dataBuffer = new DataBufferInt(size + (dataBitOffset + 31) / 32);
break;
}
return dataBuffer;
}
/**
* Gets the offset of the specified pixel in the data array.
*
* @param x
* the X coordinate of the specified pixel.
* @param y
* the Y coordinate of the specified pixel.
* @return the offset of the specified pixel.
*/
public int getOffset(int x, int y) {
return y * scanlineStride + (x * pixelBitStride + dataBitOffset) / dataElementSize;
}
@Override
public int getSampleSize(int band) {
return pixelBitStride;
}
/**
* Gets the bit offset in the data element which is stored for the specified
* pixel of a scanline.
*
* @param x
* the pixel.
* @return the bit offset of the pixel in the data element.
*/
public int getBitOffset(int x) {
return (x * pixelBitStride + dataBitOffset) % dataElementSize;
}
@Override
public int[] getSampleSize() {
int sampleSizes[] = {
pixelBitStride
};
return sampleSizes;
}
/**
* Returns a hash code of this MultiPixelPackedSampleModel class.
*
* @return the hash code of this MultiPixelPackedSampleModel class.
*/
@Override
public int hashCode() {
int hash = 0;
int tmp = 0;
hash = width;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= height;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= numBands;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= dataType;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= scanlineStride;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= pixelBitStride;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= dataBitOffset;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= bitMask;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= dataElementSize;
tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= pixelsPerDataElement;
return hash;
}
@Override
public int getTransferType() {
if (pixelBitStride > 16) {
return DataBuffer.TYPE_INT;
} else if (pixelBitStride > 8) {
return DataBuffer.TYPE_USHORT;
} else {
return DataBuffer.TYPE_BYTE;
}
}
/**
* Gets the scanline stride of this MultiPixelPackedSampleModel.
*
* @return the scanline stride of this MultiPixelPackedSampleModel.
*/
public int getScanlineStride() {
return scanlineStride;
}
/**
* Gets the pixel bit stride of this MultiPixelPackedSampleModel.
*
* @return the pixel bit stride of this MultiPixelPackedSampleModel.
*/
public int getPixelBitStride() {
return pixelBitStride;
}
@Override
public int getNumDataElements() {
return 1;
}
/**
* Gets the data bit offset.
*
* @return the data bit offset.
*/
public int getDataBitOffset() {
return dataBitOffset;
}
/**
* This method is used by other methods of this class. The behavior of this
* method depends on the method which has been invoke this one. The argument
* methodId is used to choose valid behavior in a particular case. If
* methodId is equal to 1 it means that this method has been invoked by the
* setDataElements() method, 2 - means setPixel(), and setSample() in any
* other cases.
*
* @param x
* the x.
* @param y
* the y.
* @param obj
* the obj.
* @param data
* the data.
* @param methodId
* the method id.
* @param s
* the s.
*/
private void setSample(final int x, final int y, final Object obj, final DataBuffer data,
final int methodId, int s) {
if ((x < 0) || (y < 0) || (x >= this.width) || (y >= this.height)) {
// awt.63=Coordinates are not in bounds
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.63")); //$NON-NLS-1$
}
final int bitnum = dataBitOffset + x * pixelBitStride;
final int idx = y * scanlineStride + bitnum / dataElementSize;
final int shift = dataElementSize - (bitnum & (dataElementSize - 1)) - pixelBitStride;
final int mask = ~(bitMask << shift);
int elem = data.getElem(idx);
switch (methodId) {
case 1: { // Invoked from setDataElements()
switch (getTransferType()) {
case DataBuffer.TYPE_BYTE:
s = ((byte[])obj)[0] & 0xff;
break;
case DataBuffer.TYPE_USHORT:
s = ((short[])obj)[0] & 0xffff;
break;
case DataBuffer.TYPE_INT:
s = ((int[])obj)[0];
break;
}
break;
}
case 2: { // Invoked from setPixel()
s = ((int[])obj)[0];
break;
}
}
elem &= mask;
elem |= (s & bitMask) << shift;
data.setElem(idx, elem);
}
}
|
