# HG changeset patch # User lana # Date 1349735762 25200 # Node ID 17ab6ba65191a3e305037cfc1f1b1fe697a63aa1 # Parent 5e3adc681779037a2d33b7be6f75680619085492# Parent 7410b6bd0b77279ede0a446c2fca01fe1e00f590 Merge diff -r 5e3adc681779 -r 17ab6ba65191 jdk/src/macosx/native/sun/awt/CTextPipe.m --- a/jdk/src/macosx/native/sun/awt/CTextPipe.m Wed Jul 05 18:25:14 2017 +0200 +++ b/jdk/src/macosx/native/sun/awt/CTextPipe.m Mon Oct 08 15:36:02 2012 -0700 @@ -142,8 +142,11 @@ // get our baseline transform and font CGContextRef cgRef = qsdo->cgRef; CGAffineTransform ctmText = CGContextGetTextMatrix(cgRef); - //CGFontRef cgFont = CGContextGetFont(cgRef); + /* Save and restore of graphics context is done before the iteration. + This seems to work using our test case (see bug ID 7158350) so we are restoring it at + the end of the for loop. If we find out that save/restore outside the loop + doesn't work on all cases then we will move the Save/Restore inside the loop.*/ CGContextSaveGState(cgRef); CGAffineTransform invTx = CGAffineTransformInvert(strike->fTx); @@ -210,13 +213,9 @@ pt.x += advances[i].width; pt.y += advances[i].height; - // reset the font on the context after striking a unicode with CoreText - if (uniChar != 0) - { - // CGContextSetFont(cgRef, cgFont); - CGContextSaveGState(cgRef); - } } + // reset the font on the context after striking a unicode with CoreText + CGContextRestoreGState(cgRef); } // Using the Quartz Surface Data context, draw a hot-substituted character run diff -r 5e3adc681779 -r 17ab6ba65191 jdk/src/solaris/classes/sun/java2d/xr/XRDrawImage.java --- a/jdk/src/solaris/classes/sun/java2d/xr/XRDrawImage.java Wed Jul 05 18:25:14 2017 +0200 +++ b/jdk/src/solaris/classes/sun/java2d/xr/XRDrawImage.java Mon Oct 08 15:36:02 2012 -0700 @@ -27,6 +27,7 @@ import java.awt.*; import java.awt.geom.*; +import java.awt.image.*; import sun.java2d.*; import sun.java2d.loops.*; @@ -45,8 +46,8 @@ SurfaceData srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_GENERIC, sg.imageComp, bgColor); - if (srcData != null && !isBgOperation(srcData, bgColor)) { // TODO: Do we bail out on bgBlits? - // && srcData instanceof XRSurfaceData) { + if (srcData != null && !isBgOperation(srcData, bgColor) + && interpType <= AffineTransformOp.TYPE_BILINEAR) { SurfaceType srcType = srcData.getSurfaceType(); SurfaceType dstType = dstData.getSurfaceType(); diff -r 5e3adc681779 -r 17ab6ba65191 jdk/test/sun/java2d/pipe/InterpolationQualityTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/sun/java2d/pipe/InterpolationQualityTest.java Mon Oct 08 15:36:02 2012 -0700 @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2012, 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 7188093 8000176 + * @summary Tests each of the 3 possible methods for rendering an upscaled + * image via rendering hints for default, xrender and opengl pipelines. + * + * @author Vadim.Pakhnushev@oracle.com + * @run main/othervm -Dsun.java2d.xrender=false InterpolationQualityTest + * @run main/othervm -Dsun.java2d.xrender=True InterpolationQualityTest + * @run main/othervm -Dsun.java2d.opengl=True InterpolationQualityTest + * @run main/othervm -Dsun.java2d.d3d=false InterpolationQualityTest + * @run main/othervm -Dsun.java2d.d3d=True InterpolationQualityTest + */ + +import java.awt.*; +import java.awt.image.*; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; + +public class InterpolationQualityTest { + + private static final int testSize = 4, scaleFactor = 20, tolerance = 3; + private static final int sw = testSize * scaleFactor; + private static final int sh = testSize * scaleFactor; + + private Image testImage; + private VolatileImage vImg; + + public InterpolationQualityTest() { + testImage = createTestImage(); + } + + private Image createTestImage() { + BufferedImage bi = new BufferedImage(testSize, testSize, BufferedImage.TYPE_INT_ARGB); + Graphics2D g = bi.createGraphics(); + g.setColor(Color.BLACK); + g.fillRect(0, 0, testSize, testSize); + for (int i = 0; i < testSize; i++) { + bi.setRGB(i, i, Color.WHITE.getRGB()); + } + return bi; + } + + private BufferedImage createReferenceImage(Object hint) { + BufferedImage bi = new BufferedImage(sw, sh, BufferedImage.TYPE_INT_ARGB); + Graphics2D g2d = bi.createGraphics(); + drawImage(g2d, hint); + return bi; + } + + private void drawImage(Graphics2D g2d, Object hint) { + g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint); + g2d.drawImage(testImage, 0, 0, sw, sh, null); + } + + private GraphicsConfiguration getDefaultGC() { + return GraphicsEnvironment.getLocalGraphicsEnvironment(). + getDefaultScreenDevice().getDefaultConfiguration(); + } + + private void createVImg() { + vImg = getDefaultGC().createCompatibleVolatileImage(sw, sh); + } + + private void renderOffscreen(Object hint) { + Graphics2D g = vImg.createGraphics(); + drawImage(g, hint); + g.dispose(); + } + + private BufferedImage renderImage(Object hint) { + BufferedImage snapshot; + createVImg(); + renderOffscreen(hint); + + do { + int status = vImg.validate(getDefaultGC()); + if (status != VolatileImage.IMAGE_OK) { + if (status == VolatileImage.IMAGE_INCOMPATIBLE) { + createVImg(); + } + renderOffscreen(hint); + } + snapshot = vImg.getSnapshot(); + } while (vImg.contentsLost()); + vImg.flush(); + return snapshot; + } + + private boolean compareComponent(int comp1, int comp2) { + return Math.abs(comp1 - comp2) <= tolerance; + } + + private boolean compareRGB(int rgb1, int rgb2) { + Color col1 = new Color(rgb1); + Color col2 = new Color(rgb2); + return compareComponent(col1.getRed(), col2.getRed()) && + compareComponent(col1.getBlue(), col2.getBlue()) && + compareComponent(col1.getGreen(), col2.getGreen()) && + compareComponent(col1.getAlpha(), col2.getAlpha()); + } + + private boolean compareImages(BufferedImage img, BufferedImage ref, String imgName) { + for (int y = 0; y < ref.getHeight(); y++) { + for (int x = 0; x < ref.getWidth(); x++) { + if (!compareRGB(ref.getRGB(x, y), img.getRGB(x, y))) { + System.out.println(imgName + ".getRGB(" + x + ", " + y + ") = " + + new Color(img.getRGB(x, y)) + " != " + + new Color(ref.getRGB(x, y))); + return false; + } + } + } + return true; + } + + private boolean test(Object hint) { + BufferedImage refImage = createReferenceImage(hint); + BufferedImage resImage = renderImage(hint); + + boolean passed = compareImages(resImage, refImage, "resImage"); + System.out.println(getHintName(hint) + (passed ? " passed." : " failed.")); + if (!passed) { + dumpImage(refImage, "out_" + getHintName(hint) + "_ref.png"); + dumpImage(resImage, "out_" + getHintName(hint) + ".png"); + } + return passed; + } + + public void test() { + boolean passed = true; + passed &= test(RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR); + passed &= test(RenderingHints.VALUE_INTERPOLATION_BILINEAR); + passed &= test(RenderingHints.VALUE_INTERPOLATION_BICUBIC); + if (passed) { + System.out.println("Test PASSED."); + } else { + throw new RuntimeException("Test FAILED."); + } + } + + private String getHintName(Object hint) { + if (hint == RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR) { + return "nearest"; + } + else if (hint == RenderingHints.VALUE_INTERPOLATION_BILINEAR) { + return "bilinear"; + } + else if (hint == RenderingHints.VALUE_INTERPOLATION_BICUBIC) { + return "bicubic"; + } + else { + return "null"; + } + } + + private void dumpImage(BufferedImage bi, String name) { + try { + ImageIO.write(bi, "PNG", new File(name)); + } catch (IOException ex) { + } + } + + public static void main(String[] argv) { + InterpolationQualityTest test = new InterpolationQualityTest(); + test.test(); + } +}