test/javax/imageio/plugins/png/PngOutputTypeTest.java

/*
 * Copyright (c) 2007, 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     6549882
 * @summary Test verifies that PNG image reader creates buffered image
 *          of standart type for 8 bpp images with color type RGB or RGBAlpha
 *
 * @run     main PngOutputTypeTest
 */

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Iterator;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.ImageInputStream;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class PngOutputTypeTest {

    public static void main(String[] args) throws IOException {

        new PngOutputTypeTest(BufferedImage.TYPE_INT_RGB).doTest();

        new PngOutputTypeTest(BufferedImage.TYPE_INT_ARGB).doTest();

    }

    ImageInputStream iis;

    ImageReader reader;

    public PngOutputTypeTest(int type) throws IOException {
        this(createTestImage(type));
    }

    public PngOutputTypeTest(File f) throws IOException {
        this(ImageIO.createImageInputStream(f));
    }

    public PngOutputTypeTest(ImageInputStream iis) throws IOException {
        this.iis = iis;
        reader = ImageIO.getImageReaders(iis).next();
        reader.setInput(iis);
    }

    BufferedImage def;
    BufferedImage raw;

    ImageTypeSpecifier raw_type;

    public void doTest() throws IOException {
        /*
         * This test verifies that png images with color type RGB or RGBA
         * are decoded as buffered  image of some standard type.
         *
         * So we need to be sure that image provided by
         * user has required color type - RGB or RGBA
         */
        if (!checkImageType()) {
            System.out.println("Test IGNORED!");
            return;
        }

        def = reader.read(0);
        System.out.println("Default image type: " + def.getType());
        if (def == null || def.getType() == BufferedImage.TYPE_CUSTOM) {
            throw new RuntimeException("Test FAILED!");
        }

        raw_type = reader.getRawImageType(0);
        ImageReadParam param = reader.getDefaultReadParam();
        param.setDestinationType(raw_type);

        System.out.println("Reading with raw image type...");
        raw = reader.read(0, param);
        System.out.println("Type of raw image is " + raw.getType());

        compare(def, raw);

        Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0);
        while (types.hasNext()) {
            ImageTypeSpecifier t = types.next();
            System.out.println("Test type: " + t);
            param.setDestinationType(t);

            BufferedImage img = reader.read(0, param);
            System.out.println("Result type: " + img.getType());

            compare(def, img);
            System.out.println("Done.\n");
        }

        System.out.println("Test PASSED.");
    }

    private boolean checkImageType() throws IOException {
        IIOMetadata md  = null;
        try {
            md = reader.getImageMetadata(0);
        } catch (IOException e) {
            return false;
        }

        String format = md.getNativeMetadataFormatName();

        Node root = md.getAsTree(format);

        Node ihdr = getNode(root, "IHDR");
        if (ihdr == null) {
            throw new RuntimeException("No ihdr node: invalid png image!");
        }

        String colorType = getAttributeValue(ihdr, "colorType");
        System.out.println("ColorType: " + colorType);
        if ("RGB".equals(colorType) || "RGBAlpha".equals(colorType)) {
            // we shuld chek bitDepth
            System.out.println("Good color type!");
            String bitDepthStr = getAttributeValue(ihdr, "bitDepth");
            System.out.println("bitDepth: " + bitDepthStr);
            int bitDepth = -1;
            try {
                bitDepth = Integer.parseInt(bitDepthStr);
            } catch (NumberFormatException e) {
                throw new RuntimeException("Invalid bitDepth!");
            }
            if (bitDepth == 8) {
                /*
                 * This image is RGB or RGBA color type and
                 * 8 bit tepth. so it can be used for test
                 */
                return true;
            }
        }

        return false;
    }

    private String getAttributeValue(Node n, String attrname) {
        NamedNodeMap attrs = n.getAttributes();
        if (attrs == null) {
            return null;
        } else {
            Node a = attrs.getNamedItem(attrname);
            if (a == null) {
                return null;
            } else {
                return a.getNodeValue();
            }
        }
    }

    private Node getNode(Node root, String name) {
        Node n = root;
        return lookupNode(n, name);
    }

    private Node lookupNode(Node n, String name) {
        if (n == null) {
            return null;
        }
        if (name.equals(n.getNodeName())) {
            return n;
        } else {
            // may be next on this level?
            Node res = lookupNode(n.getNextSibling(), name);

            if (res != null) {
                return res;
            } else {
                /// try children then
                return lookupNode(n.getFirstChild(), name);
            }
        }
    }

    private static void compare(BufferedImage a, BufferedImage b) {
        int w = a.getWidth();
        int h = a.getHeight();

        if (w != b.getWidth() || h != b.getHeight()) {
            throw new RuntimeException("Test FAILED!");
        }

        for (int y = 0; y < h; y++) {
            for (int x = 0; x < w; x++) {
                if (a.getRGB(x, y) != b.getRGB(x, y)) {
                    throw new RuntimeException("Test FAILED!");
                }
            }
        }
    }

    static Color[] colors = new Color[] { Color.red, Color.green, Color.blue };

    private static ImageInputStream createTestImage(int type) throws IOException  {
        int w = 100;
        int h = 100;

        BufferedImage img = new BufferedImage(w, h, type);

        int dx = w / colors.length;

        for (int i = 0; i < colors.length; i++) {
            for (int x = i *dx; (x < (i + 1) * dx) && (x < w) ; x++) {
                for (int y = 0; y < h; y++) {
                    img.setRGB(x, y, colors[i].getRGB());
                }
            }
        }

        File pwd = new File(".");
        File out = File.createTempFile("rgba_", ".png", pwd);
        System.out.println("Create file: " + out.getAbsolutePath());
        ImageIO.write(img, "PNG", out);
        return ImageIO.createImageInputStream(out);
    }
}