+ * This is intended to serve as a helper class for more specific test cases. + */ +public class GifComparison { + + /** + * This inspects the last frame of a gif and throws an Error / Exception + * if ImageIO and ToolkitImage produce different BufferedImage renderings. + * + * @param srcURL the URL of the image to inspect + * + * @return the last frame encoded as a TYPE_INT_ARGB image. + *
+ * Unit tests may further inspect this image to make sure certain
+ * conditions are met.
+ */
+ public static BufferedImage run(URL srcURL) throws Throwable {
+ System.out.println("Comparing ImageIO vs ToolkitImage rendering of " +
+ srcURL);
+ ImageIOModel ioModel = new ImageIOModel(srcURL);
+ AWTModel awtModel = new AWTModel(srcURL);
+
+ BufferedImage lastImage = null;
+
+ int a = ioModel.frames.size() - 1;
+ BufferedImage ioImg = ioModel.getFrame(a);
+ BufferedImage awtImage = awtModel.getFrame(a);
+
+ lastImage = awtImage;
+
+ if (!(ioImg.getWidth() == awtImage.getWidth() &&
+ ioImg.getHeight() == awtImage.getHeight()))
+ throw new Error("These images are not the same size: " +
+ ioImg.getWidth() + "x" + ioImg.getHeight() + " vs " +
+ awtImage.getWidth() + "x" + awtImage.getHeight());
+
+ for (int y = 0; y < ioImg.getHeight(); y++) {
+ for (int x = 0; x < ioImg.getWidth(); x++) {
+ int argb1 = ioImg.getRGB(x, y);
+ int argb2 = awtImage.getRGB(x, y);
+
+ int alpha1 = (argb1 & 0xff000000) >> 24;
+ int alpha2 = (argb2 & 0xff000000) >> 24;
+ if (alpha1 == 0 && alpha2 == 0) {
+ continue;
+ } else if (alpha1 == 0 || alpha2 == 0) {
+ throw new Error("pixels at (" + x + ", " + y +
+ ") have different opacities: " +
+ Integer.toUnsignedString(argb1, 16) + " vs " +
+ Integer.toUnsignedString(argb2, 16));
+ }
+ int rgb1 = argb1 & 0xffffff;
+ int rgb2 = argb2 & 0xffffff;
+ if (rgb1 != rgb2) {
+ throw new Error("pixels at (" + x + ", " + y +
+ ") have different opaque RGB values: " +
+ Integer.toUnsignedString(rgb1, 16) + " vs " +
+ Integer.toUnsignedString(rgb2, 16));
+ }
+ }
+ }
+ System.out.println("Passed");
+ return lastImage;
+ }
+}
+
+/**
+ * This identifies frames of a GIF image using ImageIO classes.
+ */
+class ImageIOModel {
+
+ record Frame(int x, int y, int w, int h, String disposalMethod,
+ int transparentColorIndex) {}
+
+ private final URL url;
+ private int width, height;
+
+ final List frames = new LinkedList<>();
+ private Color backgroundColor;
+
+ ImageIOModel(URL url) throws Exception {
+ this.url = url;
+
+ ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
+ try {
+ initialize(reader);
+ } finally {
+ reader.dispose();
+ }
+ }
+
+ private void initialize(ImageReader reader) throws Exception {
+ reader.setInput(ImageIO.createImageInputStream(url.openStream()));
+ IIOMetadata metadata = reader.getStreamMetadata();
+ IIOMetadataNode globalRoot = (IIOMetadataNode) metadata.getAsTree(
+ metadata.getNativeMetadataFormatName());
+
+ NodeList globalScreenDescriptor = globalRoot.getElementsByTagName(
+ "LogicalScreenDescriptor");
+ if (globalScreenDescriptor.getLength() > 0) {
+ IIOMetadataNode screenDescriptor = (IIOMetadataNode)
+ globalScreenDescriptor.item(0);
+
+ if (screenDescriptor != null) {
+ width = Integer.parseInt(
+ screenDescriptor.getAttribute("logicalScreenWidth"));
+ height = Integer.parseInt(
+ screenDescriptor.getAttribute("logicalScreenHeight"));
+ }
+ }
+
+ NodeList globalColorTable = globalRoot.getElementsByTagName(
+ "GlobalColorTable");
+ if (globalColorTable.getLength() > 0) {
+ IIOMetadataNode colorTable = (IIOMetadataNode)
+ globalColorTable.item(0);
+
+ if (colorTable != null) {
+ String bgIndex = colorTable.getAttribute(
+ "backgroundColorIndex");
+ IIOMetadataNode colorEntry = (IIOMetadataNode)
+ colorTable.getFirstChild();
+ while (colorEntry != null) {
+ if (colorEntry.getAttribute("index").equals(bgIndex)) {
+ int red = Integer.parseInt(colorEntry.getAttribute(
+ "red"));
+ int green = Integer.parseInt(colorEntry.getAttribute(
+ "green"));
+ int blue = Integer.parseInt(colorEntry.getAttribute(
+ "blue"));
+
+ backgroundColor = new Color(red, green, blue);
+ break;
+ }
+
+ colorEntry = (IIOMetadataNode) colorEntry.getNextSibling();
+ }
+ }
+ }
+
+ int frameCount = reader.getNumImages(true);
+
+ for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+ IIOMetadataNode root = (IIOMetadataNode) reader.
+ getImageMetadata(frameIndex).
+ getAsTree("javax_imageio_gif_image_1.0");
+ IIOMetadataNode gce = (IIOMetadataNode) root.
+ getElementsByTagName("GraphicControlExtension").item(0);
+ NodeList children = root.getChildNodes();
+ int transparentColorIndex = -1;
+ if ("TRUE".equalsIgnoreCase(gce.getAttribute(
+ "transparentColorFlag"))) {
+ transparentColorIndex = Integer.parseInt(gce.getAttribute(
+ "transparentColorIndex"));
+ }
+
+ String disposalMethodStr = gce.getAttribute("disposalMethod");
+
+ int frameX = 0;
+ int frameY = 0;
+ int frameWidth = width;
+ int frameHeight = height;
+
+ for (int nodeIndex = 0; nodeIndex < children.getLength();
+ nodeIndex++) {
+ Node nodeItem = children.item(nodeIndex);
+
+ if (nodeItem.getNodeName().equals("ImageDescriptor")) {
+ NamedNodeMap map = nodeItem.getAttributes();
+
+ frameX = Integer.parseInt(map.getNamedItem(
+ "imageLeftPosition").getNodeValue());
+ frameY = Integer.parseInt(map.getNamedItem(
+ "imageTopPosition").getNodeValue());
+ frameWidth = Integer.parseInt(map.getNamedItem(
+ "imageWidth").getNodeValue());
+ frameHeight = Integer.parseInt(map.getNamedItem(
+ "imageHeight").getNodeValue());
+ width = Math.max(width, frameX + frameWidth);
+ height = Math.max(height, frameY + frameHeight);
+ }
+ }
+
+ frames.add(new Frame(frameX, frameY, frameWidth, frameHeight,
+ disposalMethodStr, transparentColorIndex));
+ }
+ }
+
+ public BufferedImage getFrame(int frameIndex) throws Exception {
+ ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
+ reader.setInput(ImageIO.createImageInputStream(url.openStream()));
+ try {
+ BufferedImage image = new BufferedImage(width, height,
+ BufferedImage.TYPE_INT_ARGB);
+ BufferedImage previousImage = null;
+
+ for (int a = 0; a <= frameIndex; a++) {
+ Frame f = frames.get(a);
+ if (Objects.equals(f.disposalMethod, "restoreToPrevious")) {
+ if (previousImage == null) {
+ previousImage = new BufferedImage(image.getWidth(),
+ image.getHeight(),
+ BufferedImage.TYPE_INT_ARGB);
+ }
+ }
+
+ if (previousImage != null) {
+ Graphics2D g = previousImage.createGraphics();
+ g.setComposite(AlphaComposite.Clear);
+ g.fillRect(0, 0, image.getWidth(), image.getHeight());
+ g.setComposite(AlphaComposite.SrcOver);
+ g.drawImage(image, 0, 0, null);
+ g.dispose();
+ }
+
+ BufferedImage frame = reader.read(a);
+ Graphics2D g = image.createGraphics();
+ g.drawImage(frame, f.x, f.y, null);
+ g.dispose();
+ IndexColorModel icm = (IndexColorModel) frame.getColorModel();
+
+ if (a != frameIndex) {
+ switch (f.disposalMethod) {
+ case "restoreToBackgroundColor" -> {
+ g = image.createGraphics();
+ int t = icm.getTransparentPixel();
+ if (t >= 0 && t == f.transparentColorIndex) {
+ g.setComposite(AlphaComposite.Clear);
+ g.fillRect(f.x, f.y, f.w, f.h);
+ } else {
+ g.setColor(backgroundColor);
+ g.fillRect(f.x, f.y, f.w, f.h);
+ }
+ g.dispose();
+ }
+ case "restoreToPrevious" -> {
+ g = image.createGraphics();
+ g.setComposite(AlphaComposite.Clear);
+ g.fillRect(f.x, f.y, f.w, f.h);
+ g.setComposite(AlphaComposite.SrcOver);
+ g.drawImage(previousImage, f.x, f.y,
+ f.x + f.w, f.y + f.h,
+ f.x, f.y,
+ f.x + f.w, f.y + f.h, null);
+ g.dispose();
+ }
+ }
+ }
+ }
+
+ return image;
+ } finally {
+ reader.dispose();
+ }
+ }
+}
+
+
+/**
+ * This identifies frames of a GIF image using ToolkitImage / ImageProducer.
+ */
+class AWTModel {
+ private final URL url;
+
+ AWTModel(URL url) {
+ this.url = url;
+ }
+
+ public BufferedImage getFrame(int frameIndex) {
+ // Unfortunately the AWT gif decoder calls Thread.sleep if the frame
+ // delay is non-zero. So this method may take a long time to render a
+ // frame simply because the decoder is calling Thread.sleep constantly.
+
+ Image image = Toolkit.getDefaultToolkit().createImage(url);
+
+ AtomicReference