/*
* 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$
* Created on 10.11.2005
*
*/
package org.apache.harmony.awt.gl;
import java.awt.color.ColorSpace;
import java.awt.image.BandedSampleModel;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.ComponentSampleModel;
import java.awt.image.DirectColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.MultiPixelPackedSampleModel;
import java.awt.image.PixelInterleavedSampleModel;
import java.awt.image.SampleModel;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.WritableRaster;
import org.apache.harmony.awt.gl.color.LUTColorConverter;
import org.apache.harmony.awt.gl.image.DataBufferListener;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* This class represent Surface for different types of Images (BufferedImage,
* OffscreenImage and so on)
*/
public class ImageSurface extends Surface implements DataBufferListener {
boolean nativeDrawable = true;
int surfaceType;
int csType;
ColorModel cm;
WritableRaster raster;
Object data;
boolean needToRefresh = true;
boolean dataTaken = false;
private long cachedDataPtr; // Pointer for cached Image Data
private boolean alphaPre; // Cached Image Data alpha premultiplied
public ImageSurface(ColorModel cm, WritableRaster raster){
this(cm, raster, Surface.getType(cm, raster));
}
public ImageSurface(ColorModel cm, WritableRaster raster, int type){
if (!cm.isCompatibleRaster(raster)) {
// awt.4D=The raster is incompatible with this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$
}
this.cm = cm;
this.raster = raster;
surfaceType = type;
data = AwtImageBackdoorAccessor.getInstance().
getData(raster.getDataBuffer());
ColorSpace cs = cm.getColorSpace();
transparency = cm.getTransparency();
width = raster.getWidth();
height = raster.getHeight();
// For the moment we can build natively only images which have
// sRGB, Linear_RGB, Linear_Gray Color Space and type different
// from BufferedImage.TYPE_CUSTOM
if(cs == LUTColorConverter.sRGB_CS){
csType = sRGB_CS;
}else if(cs == LUTColorConverter.LINEAR_RGB_CS){
csType = Linear_RGB_CS;
}else if(cs == LUTColorConverter.LINEAR_GRAY_CS){
csType = Linear_Gray_CS;
}else{
csType = Custom_CS;
nativeDrawable = false;
}
if(type == BufferedImage.TYPE_CUSTOM){
nativeDrawable = false;
}
}
@Override
public ColorModel getColorModel() {
return cm;
}
@Override
public WritableRaster getRaster() {
return raster;
}
@Override
public long getSurfaceDataPtr() {
if(surfaceDataPtr == 0L && nativeDrawable){
createSufaceStructure();
}
return surfaceDataPtr;
}
@Override
public Object getData(){
return data;
}
@Override
public boolean isNativeDrawable(){
return nativeDrawable;
}
@Override
public int getSurfaceType() {
return surfaceType;
}
/**
* Creates native Surface structure which used for native blitting
*/
private void createSufaceStructure(){
int cmType = 0;
int numComponents = cm.getNumComponents();
boolean hasAlpha = cm.hasAlpha();
boolean isAlphaPre = cm.isAlphaPremultiplied();
int transparency = cm.getTransparency();
int bits[] = cm.getComponentSize();
int pixelStride = cm.getPixelSize();
int masks[] = null;
int colorMap[] = null;
int colorMapSize = 0;
int transpPixel = -1;
boolean isGrayPallete = false;
SampleModel sm = raster.getSampleModel();
int smType = 0;
int dataType = sm.getDataType();
int scanlineStride = 0;
int bankIndeces[] = null;
int bandOffsets[] = null;
int offset = raster.getDataBuffer().getOffset();
if(cm instanceof DirectColorModel){
cmType = DCM;
DirectColorModel dcm = (DirectColorModel) cm;
masks = dcm.getMasks();
smType = SPPSM;
SinglePixelPackedSampleModel sppsm = (SinglePixelPackedSampleModel) sm;
scanlineStride = sppsm.getScanlineStride();
}else if(cm instanceof IndexColorModel){
cmType = ICM;
IndexColorModel icm = (IndexColorModel) cm;
colorMapSize = icm.getMapSize();
colorMap = new int[colorMapSize];
icm.getRGBs(colorMap);
transpPixel = icm.getTransparentPixel();
isGrayPallete = Surface.isGrayPallete(icm);
if(sm instanceof MultiPixelPackedSampleModel){
smType = MPPSM;
MultiPixelPackedSampleModel mppsm =
(MultiPixelPackedSampleModel) sm;
scanlineStride = mppsm.getScanlineStride();
}else if(sm instanceof ComponentSampleModel){
smType = CSM;
ComponentSampleModel csm =
(ComponentSampleModel) sm;
scanlineStride = csm.getScanlineStride();
}else{
// awt.4D=The raster is incompatible with this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$
}
}else if(cm instanceof ComponentColorModel){
cmType = CCM;
if(sm instanceof ComponentSampleModel){
ComponentSampleModel csm = (ComponentSampleModel) sm;
scanlineStride = csm.getScanlineStride();
bankIndeces = csm.getBankIndices();
bandOffsets = csm.getBandOffsets();
if(sm instanceof PixelInterleavedSampleModel){
smType = PISM;
}else if(sm instanceof BandedSampleModel){
smType = BSM;
}else{
smType = CSM;
}
}else{
// awt.4D=The raster is incompatible with this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$
}
}else{
surfaceDataPtr = 0L;
return;
}
surfaceDataPtr = createSurfStruct(surfaceType, width, height, cmType, csType, smType, dataType,
numComponents, pixelStride, scanlineStride, bits, masks, colorMapSize,
colorMap, transpPixel, isGrayPallete, bankIndeces, bandOffsets,
offset, hasAlpha, isAlphaPre, transparency);
}
@Override
public void dispose() {
if(surfaceDataPtr != 0L){
dispose(surfaceDataPtr);
surfaceDataPtr = 0L;
}
}
public long getCachedData(boolean alphaPre){
if(nativeDrawable){
if(cachedDataPtr == 0L || needToRefresh || this.alphaPre != alphaPre){
cachedDataPtr = updateCache(getSurfaceDataPtr(), data, alphaPre);
this.alphaPre = alphaPre;
validate();
}
}
return cachedDataPtr;
}
private native long createSurfStruct(int surfaceType, int width, int height,
int cmType, int csType, int smType, int dataType,
int numComponents, int pixelStride, int scanlineStride,
int bits[], int masks[], int colorMapSize, int colorMap[],
int transpPixel, boolean isGrayPalette, int bankIndeces[],
int bandOffsets[], int offset, boolean hasAlpha, boolean isAlphaPre,
int transparency);
private native void dispose(long structPtr);
private native void setImageSize(long structPtr, int width, int height);
private native long updateCache(long structPtr, Object data, boolean alphaPre);
/**
* Supposes that new raster is compatible with an old one
* @param r
*/
public void setRaster(WritableRaster r) {
raster = r;
data = AwtImageBackdoorAccessor.getInstance().getData(r.getDataBuffer());
if (surfaceDataPtr != 0) {
setImageSize(surfaceDataPtr, r.getWidth(), r.getHeight());
}
this.width = r.getWidth();
this.height = r.getHeight();
}
@Override
public long lock() {
// TODO
return 0;
}
@Override
public void unlock() {
//TODO
}
@Override
public Surface getImageSurface() {
return this;
}
public void dataChanged() {
needToRefresh = true;
clearValidCaches();
}
public void dataTaken() {
dataTaken = true;
needToRefresh = true;
clearValidCaches();
}
public void dataReleased(){
dataTaken = false;
needToRefresh = true;
clearValidCaches();
}
@Override
public void invalidate(){
needToRefresh = true;
clearValidCaches();
}
@Override
public void validate(){
if(!needToRefresh) {
return;
}
if(!dataTaken){
needToRefresh = false;
AwtImageBackdoorAccessor ba = AwtImageBackdoorAccessor.getInstance();
ba.validate(raster.getDataBuffer());
}
}
@Override
public boolean invalidated(){
return needToRefresh;
}
}