/*
* This file is part of libbluray
* Copyright (C) 2012 libbluray
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
package java.awt;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Vector;
import java.util.Enumeration;
import java.awt.color.ColorSpace;
import java.awt.image.AreaAveragingScaleFilter;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageConsumer;
import java.awt.image.ImageProducer;
import java.awt.image.ImageObserver;
import java.awt.image.ColorModel;
import java.awt.image.BufferedImage;
class BDImageBase extends Image {
private static Constructor bufferedImageConstructor;
private Component component;
protected int width, height;
protected int[] backBuffer;
protected Area dirty;
private GraphicsConfiguration gc;
private Vector observers = new Vector();
private ImageProducer offscreenSource = null;
static {
try {
final Class c = Class.forName("java.awt.image.BufferedImage");
AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
bufferedImageConstructor = c.getDeclaredConstructors()[0];
bufferedImageConstructor.setAccessible(true);
return null;
}
}
);
} catch (ClassNotFoundException e) {
throw new AWTError("java.awt.image.BufferedImage not found");
}
}
private static BufferedImage createBuffededImage(Image image) {
try {
return (BufferedImage)bufferedImageConstructor.newInstance(new Object[] { image });
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}
BDImageBase(Component component, int width, int height, GraphicsConfiguration gc) {
this.component = component;
this.width = width;
this.height = height;
this.gc = gc;
if (width > 0 && height > 0)
backBuffer = new int[width * height];
dirty = new Area(width, height);
offscreenSource = new BDOffScreenImageSource(backBuffer, width, height);
}
public void flush() {
}
public Graphics getGraphics() {
return new BDGraphics((BDImage)this);
}
public int getWidth() {
return width;
}
public int getWidth(ImageObserver observer) {
if (width < 0)
addObserver(observer);
return width;
}
public int getHeight() {
return height;
}
public int getHeight(ImageObserver observer) {
if (height < 0)
addObserver(observer);
return height;
}
public Object getProperty(String name) {
return null;
}
public Object getProperty(String name, ImageObserver observer) {
return null;
}
public String[] getPropertyNames() {
return null;
}
public Image getScaledInstance(int width, int height, int hints) {
BDImageConsumer scaledImage = new BDImageConsumer(null);
AreaAveragingScaleFilter scaleFilter =
new AreaAveragingScaleFilter(width, height);
scaleFilter = (AreaAveragingScaleFilter)scaleFilter.getFilterInstance(scaledImage);
scaleFilter.setDimensions(this.width, this.height);
scaleFilter.setPixels(0, 0, this.width, this.height,
ColorModel.getRGBdefault(), backBuffer, 0, this.width);
scaleFilter.imageComplete(ImageConsumer.STATICIMAGEDONE);
return scaledImage;
}
public ImageProducer getSource() {
return offscreenSource;
}
public Component getComponent() {
return component;
}
protected int[] getBdBackBuffer() {
return backBuffer;
}
protected int[] getBackBuffer() {
System.err.println("**** BDIMAGE GETBACKBUFFER ****");
return backBuffer;
}
protected Area getDirtyArea() {
return dirty;
}
public GraphicsConfiguration getGraphicsConfiguration() {
return gc;
}
protected void addObserver(ImageObserver observer) {
if (observer != null && !isObserver(observer))
observers.addElement(observer);
}
protected boolean isObserver(ImageObserver observer) {
return observers.contains(observer);
}
protected void removeObserver(ImageObserver observer) {
observers.removeElement(observer);
}
protected void notifyObservers(Image img, int info, int x, int y, int w, int h) {
Enumeration enumeration = observers.elements();
Vector acquired = null;
while (enumeration.hasMoreElements()) {
ImageObserver observer = (ImageObserver)enumeration.nextElement();
if (!observer.imageUpdate(img, info, x, y, w, h)) {
if (acquired == null) {
acquired = new Vector();
}
acquired.addElement(observer);
}
}
if (acquired != null) {
enumeration = acquired.elements();
while (enumeration.hasMoreElements()) {
ImageObserver observer = (ImageObserver)enumeration.nextElement();
removeObserver(observer);
}
}
}
public int getType() {
return BufferedImage.TYPE_INT_ARGB;
}
public ColorModel getColorModel() {
return new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, true,
DataBuffer.TYPE_INT);
}
public int getRGB(int x, int y) {
return backBuffer[y * width + x];
}
public int[] getRGB(int x, int y, int w, int h, int[] rgbArray, int offset, int scansize) {
if (rgbArray == null)
rgbArray = new int[offset + h * scansize];
for (int i = 0; i < h; i++)
System.arraycopy(backBuffer, (y + i) * width + x,
rgbArray, i * scansize + offset,
w);
return rgbArray;
}
public void setRGB(int x, int y, int rgb) {
backBuffer[y * width + x] = rgb;
dirty.add(x, y);
}
public void setRGB(int x, int y, int w, int h, int[] rgbArray, int offset, int scansize) {
for (int i = 0; i < h; i++)
System.arraycopy(rgbArray, i * scansize + offset,
backBuffer, (y + i) * width + x,
w);
dirty.add(new Rectangle(x, y, w, h));
}
public BufferedImage getSubimage(int x, int y, int w, int h) {
BDImage image = new BDImage(component, w, h, gc);
int[] rgbArray = image.getBdBackBuffer();
getRGB(x, y, w, h, rgbArray, 0, w);
return createBuffededImage(image);
}
public static BufferedImage getBuffededImage(int w, int h, GraphicsConfiguration gc) {
BDImage image = new BDImage(null, w, h, gc);
return createBuffededImage(image);
}
}