/*
* Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 4641872
* @summary Tests writing compression modes of BMP plugin
* @modules java.desktop/com.sun.imageio.plugins.bmp
*/
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.PixelInterleavedSampleModel;
import java.awt.image.Raster;
import java.awt.image.SampleModel;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.WritableRaster;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.plugins.bmp.BMPImageWriteParam;
import javax.imageio.stream.ImageOutputStream;
import javax.swing.JComponent;
import javax.swing.JFrame;
import com.sun.imageio.plugins.bmp.BMPMetadata;
public class BMPCompressionTest {
static final String format = "BMP";
public static void main(String[] args) {
ImageWriter iw = null;
Iterator writers = ImageIO.getImageWritersByFormatName(format);
if (!writers.hasNext()) {
throw new RuntimeException("No available Image writer for "+format);
}
iw = (ImageWriter)writers.next();
Iterator tests = Test.createTestSet(iw);
while(tests.hasNext()) {
Test t = (Test)tests.next();
System.out.println(t.getDescription());
t.doTest();
}
}
static class Test {
static ImageWriter iw;
private BufferedImage img;
private String description;
private BMPImageWriteParam param;
private IIOMetadata meta;
public static Iterator createTestSet(ImageWriter w) {
List l = new LinkedList();
Test.iw = w;
// variate compression types
BMPImageWriteParam param = (BMPImageWriteParam)iw.getDefaultWriteParam();
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionType("BI_RGB");
if (param.canWriteCompressed()) {
String[] cTypes = param.getCompressionTypes();
String[] cDescr = param.getCompressionQualityDescriptions();
float[] cValues = param.getCompressionQualityValues();
if (cDescr == null) {
System.out.println("There are no compression quality description!");
} else {
for(int i=0; i<cDescr.length; i++) {
System.out.println("Quality[" + i + "]=\""+cDescr[i]+"\"");
}
}
if (cValues == null) {
System.out.println("There are no compression quality values!");
} else {
for(int i=0; i<cValues.length; i++) {
System.out.println("Value["+i+"]=\""+cValues[i]+"\"");
}
}
for(int i=0; i<cTypes.length; i++) {
String compressionType = cTypes[i];
BufferedImage img = null;
int type = BufferedImage.TYPE_INT_BGR;
try {
img = createTestImage(type);
if (compressionType.equals("BI_RLE8")) {
img = createTestImage2(8, DataBuffer.TYPE_BYTE);
} else if (compressionType.equals("BI_RLE4")) {
img = createTestImage3(4, DataBuffer.TYPE_BYTE);
} else if (compressionType.equals("BI_BITFIELDS")) {
img = createTestImage4(32);
}
} catch (IOException ex) {
throw new RuntimeException("Unable to create test image");
}
BMPImageWriteParam p = (BMPImageWriteParam)iw.getDefaultWriteParam();
System.out.println("Current compression type is \""+cTypes[i]+"\"");
p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
p.setCompressionType(compressionType);
IIOMetadata md = iw.getDefaultImageMetadata(new ImageTypeSpecifier(img), p);
l.add( new Test(p, md, img));
}
}
// }
return l.iterator();
}
private Test(BMPImageWriteParam p, IIOMetadata md, BufferedImage i) {
param = p;
meta = md;
img = i;
description = "Compression type is " + p.getCompressionType();
}
public String getDescription() {
return description;
}
public void doTest() {
try {
System.out.println(this.getDescription());
if (param.getCompressionMode() != ImageWriteParam.MODE_EXPLICIT) {
System.out.println("Warning: compression mode is not MODE_EXPLICIT");
}
// change metadata according to ImageWriteParam
IIOMetadata new_meta = iw.convertImageMetadata(meta, new ImageTypeSpecifier(img), param);
IIOImage iio_img = new IIOImage(img, null, new_meta);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
iw.setOutput(ios);
System.out.print("write image...");
System.out.println("Current compression Type is \""+param.getCompressionType()+"\"");
iw.write(new_meta, iio_img, param);
//iw.write(iio_img);
System.out.println("OK");
System.out.print("read image ... ");
ios.flush();
byte[] ba_image = baos.toByteArray();
System.out.println("Array length=" + ba_image.length);
FileOutputStream fos = new FileOutputStream(new File(param.getCompressionType()+".bmp"));
fos.write(ba_image);
fos.flush();
fos = null;
ByteArrayInputStream bais = new ByteArrayInputStream(ba_image);
ImageReader ir = ImageIO.getImageReader(iw);
ir.setInput(ImageIO.createImageInputStream(bais));
BufferedImage res = ir.read(0);
System.out.println("OK");
if (!param.getCompressionType().equals("BI_JPEG")) {
System.out.print("compare images ... ");
boolean r = compare(img,res);
System.out.println(r?"OK":"FAILED");
if (!r) {
throw new RuntimeException("Compared images are not equals. Test failed.");
}
}
BMPMetadata mdata = (BMPMetadata)ir.getImageMetadata(0);
if (!param.getCompressionType().equals(param.getCompressionTypes()[mdata.compression])) {
throw new RuntimeException("Different compression value");
}
} catch (Exception ex) {
ex.printStackTrace();
throw new RuntimeException("Unexpected exception: " + ex);
}
}
private boolean compare(final BufferedImage in, final BufferedImage out) {
final int width = in.getWidth();
int height = in.getHeight();
if (out.getWidth() != width || out.getHeight() != height) {
throw new RuntimeException("Dimensions changed!");
}
Raster oldras = in.getRaster();
ColorModel oldcm = in.getColorModel();
Raster newras = out.getRaster();
ColorModel newcm = out.getColorModel();
for (int j = 0; j < height; j++) {
for (int i = 0; i < width; i++) {
Object oldpixel = oldras.getDataElements(i, j, null);
int oldrgb = oldcm.getRGB(oldpixel);
int oldalpha = oldcm.getAlpha(oldpixel);
Object newpixel = newras.getDataElements(i, j, null);
int newrgb = newcm.getRGB(newpixel);
int newalpha = newcm.getAlpha(newpixel);
if (newrgb != oldrgb ||
newalpha != oldalpha) {
// showDiff(in, out);
throw new RuntimeException("Pixels differ at " + i +
", " + j + " new = " + Integer.toHexString(newrgb) + " old = " + Integer.toHexString(oldrgb));
}
}
}
return true;
}
private static BufferedImage createTestImage2(int nbits, int transfertype) {
final int colorShift = 2;
int SIZE = 256;
BufferedImage image = null;
ColorSpace colorSpace =
ColorSpace.getInstance(ColorSpace.CS_GRAY);
ColorModel colorModel =
new ComponentColorModel(colorSpace,
new int[] {nbits},
false,
false,
Transparency.OPAQUE,
transfertype);
SampleModel sampleModel =
new PixelInterleavedSampleModel(transfertype,
SIZE,
SIZE,
1,
SIZE,
new int[] {0});
image =
new BufferedImage(colorModel,
Raster.createWritableRaster(sampleModel, null),
false, null);
WritableRaster raster = image.getWritableTile(0, 0);
int[] samples = raster.getSamples(0, 0, SIZE, SIZE, 0, (int[])null);
int off = 0;
int[] row = new int[SIZE];
for(int i = 0; i < SIZE; i++) {
Arrays.fill(row, i << colorShift);
System.arraycopy(row, 0, samples, off, SIZE);
off += SIZE;
}
raster.setSamples(0, 0, SIZE, SIZE, 0, samples);
return image;
}
private static BufferedImage createTestImage3(int nbits, int transfertype) {
final int colorShift = 2;
int SIZE = 256;
BufferedImage image = null;
ColorSpace colorSpace =
ColorSpace.getInstance(ColorSpace.CS_sRGB);
ColorModel colorModel =
new IndexColorModel(nbits,
4,
new byte[] { (byte)255, 0, 0, (byte)255},
new byte[] { 0, (byte)255, 0, (byte)255},
new byte[] { 0, 0, (byte)255, (byte)255});
SampleModel sampleModel =
new PixelInterleavedSampleModel(transfertype,
SIZE,
SIZE,
1,
SIZE,
new int[] {0});
image =
new BufferedImage(colorModel,
Raster.createWritableRaster(sampleModel, null),
false, null);
Graphics2D g = image.createGraphics();
g.setColor(Color.white);
g.fillRect(0,0, SIZE, SIZE);
g.setColor(Color.red);
g.fillOval(10, 10, SIZE -20, SIZE-20);
return image;
}
private static BufferedImage createTestImage4(int nbits) {
int SIZE = 10;
BufferedImage image = null;
ColorSpace colorSpace =
ColorSpace.getInstance(ColorSpace.CS_sRGB);
ColorModel colorModel =
new DirectColorModel(colorSpace,
nbits, 0xff0000, 0x00ff00, 0x0000ff, 0x000000, false, DataBuffer.TYPE_INT);
SampleModel sampleModel =
new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT,
SIZE,
SIZE,
new int[] { 0xff0000, 0x00ff00, 0x0000ff} );
image =
new BufferedImage(colorModel,
Raster.createWritableRaster(sampleModel, null),
false, null);
Graphics2D g = image.createGraphics();
g.setColor(Color.red);
g.fillRect(0,0, SIZE, SIZE);
g.setColor(Color.green);
//g.fillOval(10, 10, SIZE -20, SIZE-20);
g.drawLine(7, 0, 7, SIZE);
g.setColor(Color.blue);
g.drawLine(1, 0, 1, SIZE);
g.setColor(Color.white);
g.drawLine(3, 0, 3, SIZE);
g.setColor(Color.yellow);
g.drawLine(5, 0, 5, SIZE);
return image;
}
private static BufferedImage createTestImage(int type)
throws IOException {
int w = 200;
int h = 200;
BufferedImage b = new BufferedImage(w, h, type);
Graphics2D g = b.createGraphics();
g.setColor(Color.white);
g.fillRect(0,0, w, h);
g.setColor(Color.black);
g.fillOval(10, 10, w -20, h-20);
return b;
}
}
private static void showDiff(final BufferedImage in,
final BufferedImage out) {
final int width = in.getWidth();
final int height = in.getHeight();
JFrame f = new JFrame("");
f.getContentPane().add( new JComponent() {
public Dimension getPreferredSize() {
return new Dimension(2*width+2, height);
}
public void paintComponent(Graphics g) {
g.setColor(Color.black);
g.drawImage(in, 0,0, null);
g.drawImage(out, width+2, 0, null);
}
});
f.pack();
f.setVisible(true);
}
}
