/*
* Copyright (c) 2015, 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.
*/
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import javax.imageio.event.IIOWriteProgressListener;
import javax.imageio.stream.ImageOutputStream;
import static java.awt.image.BufferedImage.TYPE_BYTE_BINARY;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.SampleModel;
import java.awt.image.WritableRaster;
import java.util.Vector;
import javax.imageio.IIOImage;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;
/**
* @test
* @bug 8144245
* @summary Ensure aborting write works properly for a TIFF sequence.
*/
public final class WriteToSequenceAfterAbort implements IIOWriteProgressListener {
private volatile boolean abortFlag = true;
private volatile boolean isAbortCalled;
private volatile boolean isCompleteCalled;
private volatile boolean isProgressCalled;
private volatile boolean isStartedCalled;
private static final int WIDTH = 100;
private static final int HEIGHT = 100;
private static final int NUM_TILES_XY = 3;
private class TiledImage implements RenderedImage {
private final BufferedImage tile;
private final BufferedImage image;
private final int numXTiles, numYTiles;
private boolean isImageInitialized = false;
TiledImage(BufferedImage tile, int numXTiles, int numYTiles) {
this.tile = tile;
this.numXTiles = numXTiles;
this.numYTiles = numYTiles;
image = new BufferedImage(getWidth(), getHeight(), tile.getType());
}
@Override
public Vector<RenderedImage> getSources() {
return null;
}
@Override
public Object getProperty(String string) {
return java.awt.Image.UndefinedProperty;
}
@Override
public String[] getPropertyNames() {
return new String[0];
}
@Override
public ColorModel getColorModel() {
return tile.getColorModel();
}
@Override
public SampleModel getSampleModel() {
return tile.getSampleModel();
}
@Override
public int getWidth() {
return numXTiles*tile.getWidth();
}
@Override
public int getHeight() {
return numYTiles*tile.getHeight();
}
@Override
public int getMinX() {
return 0;
}
@Override
public int getMinY() {
return 0;
}
@Override
public int getNumXTiles() {
return numXTiles;
}
@Override
public int getNumYTiles() {
return numYTiles;
}
@Override
public int getMinTileX() {
return 0;
}
@Override
public int getMinTileY() {
return 0;
}
@Override
public int getTileWidth() {
return tile.getWidth();
}
@Override
public int getTileHeight() {
return tile.getHeight();
}
@Override
public int getTileGridXOffset() {
return 0;
}
@Override
public int getTileGridYOffset() {
return 0;
}
@Override
public Raster getTile(int x, int y) {
WritableRaster r = tile.getRaster();
return r.createWritableTranslatedChild(x*tile.getWidth(),
y*tile.getHeight());
}
@Override
public Raster getData() {
return getAsBufferedImage().getData();
}
@Override
public Raster getData(Rectangle r) {
return getAsBufferedImage().getData(r);
}
@Override
public WritableRaster copyData(WritableRaster wr) {
return getAsBufferedImage().copyData(wr);
}
public BufferedImage getAsBufferedImage() {
synchronized (image) {
if (!isImageInitialized) {
int tx0 = getMinTileX(), ty0 = getMinTileY();
int txN = tx0 + getNumXTiles(), tyN = ty0 + getNumYTiles();
for (int j = ty0; j < tyN; j++) {
for (int i = tx0; i < txN; i++) {
image.setData(getTile(i, j));
}
}
}
isImageInitialized = true;
}
return image;
}
}
private void test(final ImageWriter writer) throws IOException {
String suffix = writer.getOriginatingProvider().getFileSuffixes()[0];
// Image initialization
BufferedImage imageUpperLeft =
new BufferedImage(WIDTH, HEIGHT, TYPE_BYTE_BINARY);
Graphics2D g = imageUpperLeft.createGraphics();
g.setColor(Color.WHITE);
g.fillRect(0, 0, WIDTH/2, HEIGHT/2);
g.dispose();
BufferedImage imageLowerRight =
new BufferedImage(WIDTH, HEIGHT, TYPE_BYTE_BINARY);
g = imageLowerRight.createGraphics();
g.setColor(Color.WHITE);
g.fillRect(WIDTH/2, HEIGHT/2, WIDTH/2, HEIGHT/2);
g.dispose();
TiledImage[] images = new TiledImage[] {
new TiledImage(imageUpperLeft, NUM_TILES_XY, NUM_TILES_XY),
new TiledImage(imageUpperLeft, NUM_TILES_XY, NUM_TILES_XY),
new TiledImage(imageLowerRight, NUM_TILES_XY, NUM_TILES_XY),
new TiledImage(imageLowerRight, NUM_TILES_XY, NUM_TILES_XY)
};
// File initialization
File file = File.createTempFile("temp", "." + suffix);
file.deleteOnExit();
FileOutputStream fos = new SkipWriteOnAbortOutputStream(file);
ImageOutputStream ios = ImageIO.createImageOutputStream(fos);
writer.setOutput(ios);
writer.addIIOWriteProgressListener(this);
writer.prepareWriteSequence(null);
boolean[] abortions = new boolean[] {true, false, true, false};
for (int i = 0; i < 4; i++) {
abortFlag = abortions[i];
isAbortCalled = false;
isCompleteCalled = false;
isProgressCalled = false;
isStartedCalled = false;
TiledImage image = images[i];
if (abortFlag) {
// This write will be aborted, and file will not be touched
writer.writeToSequence(new IIOImage(image, null, null), null);
if (!isStartedCalled) {
throw new RuntimeException("Started should be called");
}
if (!isProgressCalled) {
throw new RuntimeException("Progress should be called");
}
if (!isAbortCalled) {
throw new RuntimeException("Abort should be called");
}
if (isCompleteCalled) {
throw new RuntimeException("Complete should not be called");
}
} else {
// This write should be completed successfully and the file should
// contain correct image data.
writer.writeToSequence(new IIOImage(image, null, null), null);
if (!isStartedCalled) {
throw new RuntimeException("Started should be called");
}
if (!isProgressCalled) {
throw new RuntimeException("Progress should be called");
}
if (isAbortCalled) {
throw new RuntimeException("Abort should not be called");
}
if (!isCompleteCalled) {
throw new RuntimeException("Complete should be called");
}
}
}
writer.endWriteSequence();
writer.dispose();
ios.close();
// Validates content of the file.
ImageReader reader = ImageIO.getImageReader(writer);
ImageInputStream iis = ImageIO.createImageInputStream(file);
reader.setInput(iis);
for (int i = 0; i < 2; i++) {
System.out.println("Testing image " + i);
BufferedImage imageRead = reader.read(i);
BufferedImage imageWrite = images[2 * i].getAsBufferedImage();
for (int x = 0; x < WIDTH; ++x) {
for (int y = 0; y < HEIGHT; ++y) {
if (imageRead.getRGB(x, y) != imageWrite.getRGB(x, y)) {
throw new RuntimeException("Test failed for image " + i);
}
}
}
}
}
public static void main(final String[] args) throws IOException {
WriteToSequenceAfterAbort writeAfterAbort = new WriteToSequenceAfterAbort();
ImageWriter writer = ImageIO.getImageWritersByFormatName("TIFF").next();
writeAfterAbort.test(writer);
System.out.println("Test passed.");
}
// Callbacks
@Override
public void imageComplete(ImageWriter source) {
isCompleteCalled = true;
}
@Override
public void imageProgress(ImageWriter source, float percentageDone) {
isProgressCalled = true;
if (percentageDone > 50 && abortFlag) {
source.abort();
}
}
@Override
public void imageStarted(ImageWriter source, int imageIndex) {
isStartedCalled = true;
}
@Override
public void writeAborted(final ImageWriter source) {
isAbortCalled = true;
}
@Override
public void thumbnailComplete(ImageWriter source) {
}
@Override
public void thumbnailProgress(ImageWriter source, float percentageDone) {
}
@Override
public void thumbnailStarted(ImageWriter source, int imageIndex,
int thumbnailIndex) {
}
/**
* We need to skip writes on abort, because content of the file after abort
* is undefined.
*/
private class SkipWriteOnAbortOutputStream extends FileOutputStream {
SkipWriteOnAbortOutputStream(File file) throws FileNotFoundException {
super(file);
}
@Override
public void write(int b) throws IOException {
if (!abortFlag) {
super.write(b);
}
}
@Override
public void write(byte[] b) throws IOException {
if (!abortFlag) {
super.write(b);
}
}
@Override
public void write(byte[] b, int off, int len) throws IOException {
if (!abortFlag) {
super.write(b, off, len);
}
}
}
}