BMPSubsamplingTest.java

/*
 * Copyright (c) 2006, 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     6299168 6399660 6519600
 * @summary Test verifies that the subsampling usage does not causes color
 *          changes.
 * @run     main BMPSubsamplingTest
 * @author  andrew.brygin
 */
import java.awt.Color;
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.Raster;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.IOException;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;


public class BMPSubsamplingTest {
    private static final int TYPE_INT_GRB = 0x100;
    private static final int TYPE_INT_GBR = 0x101;
    private static final int TYPE_INT_RBG = 0x102;
    private static final int TYPE_INT_BRG = 0x103;
    private static final int TYPE_3BYTE_RGB = 0x104;
    private static final int TYPE_3BYTE_GRB = 0x105;
    private static final int TYPE_USHORT_555_GRB = 0x106;
    private static final int TYPE_USHORT_555_BGR = 0x107;
    private static final int TYPE_USHORT_565_BGR = 0x108;
    private static final int TYPE_4BPP_INDEXED = 0x109;

    private String format = "BMP";

    private int[] img_types = new int[] {
        BufferedImage.TYPE_INT_RGB,
        BufferedImage.TYPE_INT_BGR,
        TYPE_INT_GRB,
        TYPE_INT_GBR,
        TYPE_INT_RBG,
        TYPE_INT_BRG,
        BufferedImage.TYPE_USHORT_555_RGB,
        BufferedImage.TYPE_USHORT_565_RGB,
        TYPE_USHORT_555_GRB,
        TYPE_USHORT_555_BGR,
        TYPE_USHORT_565_BGR,
        BufferedImage.TYPE_3BYTE_BGR,
        TYPE_3BYTE_RGB,
        TYPE_3BYTE_GRB,
        BufferedImage.TYPE_BYTE_INDEXED,
        TYPE_4BPP_INDEXED
    };
    Color[] colors = new Color[] { Color.red, Color.green, Color.blue };

    private final int srcXSubsampling = 3;
    private final int srcYSubsampling = 3;

    int dx = 300;
    int h = 300;
    int w = dx * colors.length + srcXSubsampling;



    public BMPSubsamplingTest() throws IOException {
        ImageWriter writer =
            ImageIO.getImageWritersByFormatName(format).next();

        ImageWriteParam wparam = writer.getDefaultWriteParam();
        wparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        String[] types = wparam.getCompressionTypes();
        for (int t = 0; t < img_types.length; t++) {
            int img_type = img_types[t];
            System.out.println("Test for " + getImageTypeName(img_type));
            BufferedImage image = getTestImage(img_type);

            ImageTypeSpecifier specifier = new ImageTypeSpecifier(image);

            if (!writer.getOriginatingProvider().canEncodeImage(specifier)) {
                System.out.println("Writer does not support encoding this buffered image type.");
                continue;
            }

            for(int i=0; i<types.length; i++) {
                if ("BI_JPEG".equals(types[i])) {
                    // exclude BI_JPEG from automatic test
                    // due to color diffusion effect on the borders.
                    continue;
                }

                if (canEncodeImage(types[i], specifier, img_type)) {
                    System.out.println("compression type: " + types[i] +
                        " Supported for " + getImageTypeName(img_type));
                } else {
                    System.out.println("compression type: " + types[i] +
                        " NOT Supported for " + getImageTypeName(img_type));
                    continue;
                }
                ImageWriteParam imageWriteParam = getImageWriteParam(writer, types[i]);

                imageWriteParam.setSourceSubsampling(srcXSubsampling,
                                                     srcYSubsampling,
                                                     0, 0);
                File outputFile = new File("subsampling_test_" +
                    getImageTypeName(img_type) + "__" +
                    types[i] + ".bmp");
                ImageOutputStream ios =
                    ImageIO.createImageOutputStream(outputFile);
                writer.setOutput(ios);

                IIOImage iioImg = new IIOImage(image, null, null);

                writer.write(null, iioImg, imageWriteParam);

                ios.flush();
                ios.close();

                BufferedImage outputImage = ImageIO.read(outputFile);
                checkTestImage(outputImage);
            }
        }
    }

    private ImageWriteParam getImageWriteParam(ImageWriter writer, String value) {
        ImageWriteParam imageWriteParam = writer.getDefaultWriteParam();
        imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        imageWriteParam.setCompressionType(value);
        return imageWriteParam;
    }


    private boolean canEncodeImage(String compression,
                                   ImageTypeSpecifier imgType, int rawType)
    {
        int biType = imgType.getBufferedImageType();
        if ((!compression.equals("BI_BITFIELDS")) &&
            ((rawType == BufferedImage.TYPE_USHORT_565_RGB) ||
             (rawType == TYPE_USHORT_565_BGR)))
        {
            return false;
        }

        int bpp = imgType.getColorModel().getPixelSize();
        if (compression.equals("BI_RLE4") && bpp != 4) {
            // only 4bpp images can be encoded as BI_RLE4
            return false;
        }
        if (compression.equals("BI_RLE8") && bpp != 8) {
            // only 8bpp images can be encoded as BI_RLE8
            return false;
        }

        if (compression.equals("BI_PNG") &&
            ((rawType == TYPE_USHORT_555_GRB) ||
             (rawType == TYPE_USHORT_555_BGR)))
        {
            return false;
        }

        return true;
    }

    private String getImageTypeName(int t) {
        switch(t) {
          case BufferedImage.TYPE_INT_RGB:
              return "TYPE_INT_RGB";
          case BufferedImage.TYPE_INT_BGR:
              return "TYPE_INT_BGR";
          case TYPE_INT_GRB:
              return "TYPE_INT_GRB";
          case TYPE_INT_GBR:
              return "TYPE_INT_GBR";
          case TYPE_INT_RBG:
              return "TYPE_INT_RBG";
          case TYPE_INT_BRG:
              return "TYPE_INT_BRG";
          case BufferedImage.TYPE_USHORT_555_RGB:
              return "TYPE_USHORT_555_RGB";
          case BufferedImage.TYPE_USHORT_565_RGB:
              return "TYPE_USHORT_565_RGB";
          case TYPE_USHORT_555_GRB:
              return "TYPE_USHORT_555_GRB";
          case TYPE_USHORT_555_BGR:
              return "TYPE_USHORT_555_BGR";
          case TYPE_USHORT_565_BGR:
              return "TYPE_USHORT_565_BGR";
          case BufferedImage.TYPE_3BYTE_BGR:
              return "TYPE_3BYTE_BGR";
          case TYPE_3BYTE_RGB:
              return "TYPE_3BYTE_RGB";
          case TYPE_3BYTE_GRB:
              return "TYPE_3BYTE_GRB";
          case BufferedImage.TYPE_BYTE_INDEXED:
              return "TYPE_BYTE_INDEXED";
          case TYPE_4BPP_INDEXED:
              return "TYPE_BYTE_INDEXED (4bpp)";
          default:
              throw new IllegalArgumentException("Unknown image type: " + t);
        }
    }

    private BufferedImage getTestImage(int type) {
        BufferedImage dst = null;
        ColorModel colorModel = null;
        WritableRaster raster = null;
        switch(type) {
          case TYPE_INT_GRB:
              colorModel = new DirectColorModel(24,
                                                0x0000ff00,
                                                0x00ff0000,
                                                0x000000ff);
              break;
          case TYPE_INT_GBR:
              colorModel = new DirectColorModel(24,
                                                0x000000ff,
                                                0x00ff0000,
                                                0x0000ff00);
              break;
          case TYPE_INT_RBG:
              colorModel = new DirectColorModel(24,
                                                0x00ff0000,
                                                0x000000ff,
                                                0x0000ff00);
              break;
          case TYPE_INT_BRG:
              colorModel = new DirectColorModel(24,
                                                0x0000ff00,
                                                0x000000ff,
                                                0x00ff0000);
                break;
          case TYPE_3BYTE_RGB:
              dst = create3ByteImage(new int[] {8, 8, 8},
                                     new int[] {0, 1, 2});
              break;
          case TYPE_3BYTE_GRB:
              dst = create3ByteImage(new int[] {8, 8, 8},
                                     new int[] {1, 0, 2});
              break;
          case TYPE_USHORT_555_GRB:
              colorModel = new DirectColorModel(16,
                                                0x03E0,
                                                0x7C00,
                                                0x001F);
              break;
          case TYPE_USHORT_555_BGR:
              colorModel = new DirectColorModel(16,
                                                0x001F,
                                                0x03E0,
                                                0x7C00);
              break;
          case TYPE_USHORT_565_BGR:
              colorModel = new DirectColorModel(16,
                                                0x001F,
                                                0x07E0,
                                                0xf800);
              break;
          case TYPE_4BPP_INDEXED:
              dst = createIndexImage(4);
              break;
          default:
              dst = new BufferedImage(w, h, type);
        }
        if (dst == null) {
            raster = colorModel.createCompatibleWritableRaster(w, h);
            dst = new BufferedImage(colorModel, raster, false, null);
        }
        Graphics2D g = dst.createGraphics();
        for (int i = 0; i < colors.length; i++) {
            g.setColor(colors[i]);
            g.fillRect(i * dx, 0, dx, h);
        }
        g.dispose();
        return dst;
    }

    private BufferedImage createIndexImage(int bpp) {
        // calculate palette size
        int psize = (1 << bpp);

        // prepare palette;
        byte[] r = new byte[psize];
        byte[] g = new byte[psize];
        byte[] b = new byte[psize];

        for (int i = 0; i < colors.length; i++) {
            r[i] = (byte)(0xff & colors[i].getRed());
            g[i] = (byte)(0xff & colors[i].getGreen());
            b[i] = (byte)(0xff & colors[i].getBlue());
        }

        // now prepare appropriate index clor model
        IndexColorModel icm = new IndexColorModel(bpp, psize, r, g, b);

        return new BufferedImage(w, h, BufferedImage.TYPE_BYTE_INDEXED, icm);
    }

    private BufferedImage create3ByteImage(int[] nBits, int[] bOffs) {
        ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
        ColorModel colorModel =
            new ComponentColorModel(cs, nBits,
                                    false, false,
                                    Transparency.OPAQUE,
                                    DataBuffer.TYPE_BYTE);
        WritableRaster raster =
            Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
                                           w, h,
                                           w*3, 3,
                                           bOffs, null);
        return new BufferedImage(colorModel, raster, false, null);
    }

    private void checkTestImage(BufferedImage dst) {
        // NB: do not forget about subsampling factor.
        int x = dx / (2 * srcXSubsampling);
        int y = h / (2 * srcYSubsampling);
        System.out.println("Check result: width=" + dst.getWidth() +
            ", height=" + dst.getHeight());
        for (int i = 0; i < colors.length; i++) {
            System.out.println("\tcheck at: " + x + ", " + y);
            int srcRgb = colors[i].getRGB();
            int dstRgb = dst.getRGB(x, y);
            if (srcRgb != dstRgb) {
                throw new RuntimeException("Test failed due to wrong dst color " +
                    Integer.toHexString(dstRgb) + " at " + x + "," + y +
                    "instead of " + Integer.toHexString(srcRgb));
            }
            x += dx / srcXSubsampling;
        }
    }

    public static void main(String args[]) throws IOException {
        BMPSubsamplingTest test = new BMPSubsamplingTest();
    }
}