Examples with SurfaceType sun.java2d.loops.SurfaceType used on opensource projects

Example 6 with SurfaceType

use of sun.java2d.loops.SurfaceType in project jdk8u_jdk by JetBrains.

the class DrawImage method renderImageScale.

// Render an image using only integer scaling (no transform).
protected boolean renderImageScale(SunGraphics2D sg, Image img, Color bgColor, int interpType, int sx1, int sy1, int sx2, int sy2, double dx1, double dy1, double dx2, double dy2) {
    // for ScaledBlit operations.
    if (interpType != AffineTransformOp.TYPE_NEAREST_NEIGHBOR) {
        return false;
    }
    Region clip = sg.getCompClip();
    SurfaceData dstData = sg.surfaceData;
    int attempts = 0;
    // and try it once more
    while (true) {
        SurfaceData srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_TRANSLATESCALE, sg.imageComp, bgColor);
        if (srcData == null || isBgOperation(srcData, bgColor)) {
            return false;
        }
        try {
            SurfaceType srcType = srcData.getSurfaceType();
            SurfaceType dstType = dstData.getSurfaceType();
            return scaleSurfaceData(sg, clip, srcData, dstData, srcType, dstType, sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2);
        } catch (NullPointerException e) {
            if (!SurfaceData.isNull(dstData)) {
                // Something else caused the exception, throw it...
                throw e;
            }
            return false;
        // NOP if we have been disposed
        } catch (InvalidPipeException e) {
            // Always catch the exception; try this a couple of times
            // and fail silently if the system is not yet ready to
            // revalidate the source or dest surfaceData objects.
            ++attempts;
            // ensures sg.surfaceData is valid
            clip = sg.getCompClip();
            dstData = sg.surfaceData;
            if (SurfaceData.isNull(dstData) || SurfaceData.isNull(srcData) || (attempts > 1)) {
                return false;
            }
        }
    }
}

Example 7 with SurfaceType

use of sun.java2d.loops.SurfaceType in project jdk8u_jdk by JetBrains.

the class X11SurfaceData method getSurfaceType.

public static SurfaceType getSurfaceType(X11GraphicsConfig gc, int transparency, boolean pixmapSurface) {
    boolean transparent = (transparency == Transparency.BITMASK);
    SurfaceType sType;
    ColorModel cm = gc.getColorModel();
    switch(cm.getPixelSize()) {
        case 24:
            if (gc.getBitsPerPixel() == 24) {
                if (cm instanceof DirectColorModel) {
                    // 4517321: We will always use ThreeByteBgr for 24 bpp
                    // surfaces, regardless of the pixel masks reported by
                    // X11.  Despite ambiguity in the X11 spec in how 24 bpp
                    // surfaces are treated, it appears that the best
                    // SurfaceType for these configurations (including
                    // some Matrox Millenium and ATI Radeon boards) is
                    // ThreeByteBgr.
                    sType = transparent ? X11SurfaceData.ThreeByteBgrX11_BM : X11SurfaceData.ThreeByteBgrX11;
                } else {
                    throw new sun.java2d.InvalidPipeException("Unsupported bit " + "depth/cm combo: " + cm.getPixelSize() + ", " + cm);
                }
                break;
            }
        // Fall through for 32 bit case
        case 32:
            if (cm instanceof DirectColorModel) {
                if (((SunToolkit) java.awt.Toolkit.getDefaultToolkit()).isTranslucencyCapable(gc) && !pixmapSurface) {
                    sType = X11SurfaceData.IntArgbPreX11;
                } else {
                    if (((DirectColorModel) cm).getRedMask() == 0xff0000) {
                        sType = transparent ? X11SurfaceData.IntRgbX11_BM : X11SurfaceData.IntRgbX11;
                    } else {
                        sType = transparent ? X11SurfaceData.IntBgrX11_BM : X11SurfaceData.IntBgrX11;
                    }
                }
            } else if (cm instanceof ComponentColorModel) {
                sType = X11SurfaceData.FourByteAbgrPreX11;
            } else {
                throw new sun.java2d.InvalidPipeException("Unsupported bit " + "depth/cm combo: " + cm.getPixelSize() + ", " + cm);
            }
            break;
        case 15:
            sType = transparent ? X11SurfaceData.UShort555RgbX11_BM : X11SurfaceData.UShort555RgbX11;
            break;
        case 16:
            if ((cm instanceof DirectColorModel) && (((DirectColorModel) cm).getGreenMask() == 0x3e0)) {
                // fix for 4352984: Riva128 on Linux
                sType = transparent ? X11SurfaceData.UShort555RgbX11_BM : X11SurfaceData.UShort555RgbX11;
            } else {
                sType = transparent ? X11SurfaceData.UShort565RgbX11_BM : X11SurfaceData.UShort565RgbX11;
            }
            break;
        case 12:
            if (cm instanceof IndexColorModel) {
                sType = transparent ? X11SurfaceData.UShortIndexedX11_BM : X11SurfaceData.UShortIndexedX11;
            } else {
                throw new sun.java2d.InvalidPipeException("Unsupported bit " + "depth: " + cm.getPixelSize() + " cm=" + cm);
            }
            break;
        case 8:
            if (cm.getColorSpace().getType() == ColorSpace.TYPE_GRAY && cm instanceof ComponentColorModel) {
                sType = transparent ? X11SurfaceData.ByteGrayX11_BM : X11SurfaceData.ByteGrayX11;
            } else if (cm instanceof IndexColorModel && isOpaqueGray((IndexColorModel) cm)) {
                sType = transparent ? X11SurfaceData.Index8GrayX11_BM : X11SurfaceData.Index8GrayX11;
            } else {
                sType = transparent ? X11SurfaceData.ByteIndexedX11_BM : X11SurfaceData.ByteIndexedOpaqueX11;
            }
            break;
        default:
            throw new sun.java2d.InvalidPipeException("Unsupported bit " + "depth: " + cm.getPixelSize());
    }
    return sType;
}

Example 8 with SurfaceType

use of sun.java2d.loops.SurfaceType in project jdk8u_jdk by JetBrains.

the class DrawImage method renderImageCopy.

// Render an image using only integer translation
// (no scale or transform or sub-pixel interpolated translations).
protected boolean renderImageCopy(SunGraphics2D sg, Image img, Color bgColor, int dx, int dy, int sx, int sy, int w, int h) {
    Region clip = sg.getCompClip();
    SurfaceData dstData = sg.surfaceData;
    int attempts = 0;
    // and try it once more
    while (true) {
        SurfaceData srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_ISIDENT, sg.imageComp, bgColor);
        if (srcData == null) {
            return false;
        }
        try {
            SurfaceType srcType = srcData.getSurfaceType();
            SurfaceType dstType = dstData.getSurfaceType();
            blitSurfaceData(sg, clip, srcData, dstData, srcType, dstType, sx, sy, dx, dy, w, h, bgColor);
            return true;
        } catch (NullPointerException e) {
            if (!(SurfaceData.isNull(dstData) || SurfaceData.isNull(srcData))) {
                // Something else caused the exception, throw it...
                throw e;
            }
            return false;
        // NOP if we have been disposed
        } catch (InvalidPipeException e) {
            // Always catch the exception; try this a couple of times
            // and fail silently if the system is not yet ready to
            // revalidate the source or dest surfaceData objects.
            ++attempts;
            // ensures sg.surfaceData is valid
            clip = sg.getCompClip();
            dstData = sg.surfaceData;
            if (SurfaceData.isNull(dstData) || SurfaceData.isNull(srcData) || (attempts > 1)) {
                return false;
            }
        }
    }
}

Example 9 with SurfaceType

use of sun.java2d.loops.SurfaceType in project jdk8u_jdk by JetBrains.

the class DrawImage method renderImageXform.

protected void renderImageXform(SunGraphics2D sg, Image img, AffineTransform tx, int interpType, int sx1, int sy1, int sx2, int sy2, Color bgColor) {
    final AffineTransform itx;
    try {
        itx = tx.createInverse();
    } catch (final NoninvertibleTransformException ignored) {
        // Non-invertible transform means no output
        return;
    }
    /*
         * Find the maximum bounds on the destination that will be
         * affected by the transformed source.  First, transform all
         * four corners of the source and then min and max the resulting
         * destination coordinates of the transformed corners.
         * Note that tx already has the offset to sx1,sy1 accounted
         * for so we use the box (0, 0, sx2-sx1, sy2-sy1) as the
         * source coordinates.
         */
    final double[] coords = new double[8];
    /* corner:  UL      UR      LL      LR   */
    /* index:  0  1    2  3    4  5    6  7  */
    /* coord: (0, 0), (w, 0), (0, h), (w, h) */
    coords[2] = coords[6] = sx2 - sx1;
    coords[5] = coords[7] = sy2 - sy1;
    tx.transform(coords, 0, coords, 0, 4);
    double ddx1, ddy1, ddx2, ddy2;
    ddx1 = ddx2 = coords[0];
    ddy1 = ddy2 = coords[1];
    for (int i = 2; i < coords.length; i += 2) {
        double d = coords[i];
        if (ddx1 > d)
            ddx1 = d;
        else if (ddx2 < d)
            ddx2 = d;
        d = coords[i + 1];
        if (ddy1 > d)
            ddy1 = d;
        else if (ddy2 < d)
            ddy2 = d;
    }
    Region clip = sg.getCompClip();
    final int dx1 = Math.max((int) Math.floor(ddx1), clip.lox);
    final int dy1 = Math.max((int) Math.floor(ddy1), clip.loy);
    final int dx2 = Math.min((int) Math.ceil(ddx2), clip.hix);
    final int dy2 = Math.min((int) Math.ceil(ddy2), clip.hiy);
    if (dx2 <= dx1 || dy2 <= dy1) {
        // empty destination means no output
        return;
    }
    final SurfaceData dstData = sg.surfaceData;
    SurfaceData srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_GENERIC, sg.imageComp, bgColor);
    if (srcData == null) {
        img = getBufferedImage(img);
        srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_GENERIC, sg.imageComp, bgColor);
        if (srcData == null) {
            // REMIND: Is this correct?  Can this happen?
            return;
        }
    }
    if (isBgOperation(srcData, bgColor)) {
        // We cannot perform bg operations during transform so make
        // an opaque temp image with the appropriate background
        // and work from there.
        img = makeBufferedImage(img, bgColor, BufferedImage.TYPE_INT_RGB, sx1, sy1, sx2, sy2);
        // Temp image has appropriate subimage at 0,0 now.
        sx2 -= sx1;
        sy2 -= sy1;
        sx1 = sy1 = 0;
        srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_GENERIC, sg.imageComp, bgColor);
    }
    SurfaceType srcType = srcData.getSurfaceType();
    TransformHelper helper = TransformHelper.getFromCache(srcType);
    if (helper == null) {
        /* We have no helper for this source image type.
             * But we know that we do have helpers for both RGB and ARGB,
             * so convert to one of those types depending on transparency.
             * ARGB_PRE might be a better choice if the source image has
             * alpha, but it may cause some recursion here since we only
             * tend to have converters that convert to ARGB.
             */
        int type = ((srcData.getTransparency() == Transparency.OPAQUE) ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB);
        img = makeBufferedImage(img, null, type, sx1, sy1, sx2, sy2);
        // Temp image has appropriate subimage at 0,0 now.
        sx2 -= sx1;
        sy2 -= sy1;
        sx1 = sy1 = 0;
        srcData = dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_GENERIC, sg.imageComp, null);
        srcType = srcData.getSurfaceType();
        helper = TransformHelper.getFromCache(srcType);
    // assert(helper != null);
    }
    SurfaceType dstType = dstData.getSurfaceType();
    if (sg.compositeState <= SunGraphics2D.COMP_ALPHA) {
        /* NOTE: We either have, or we can make,
             * a MaskBlit for any alpha composite type
             */
        MaskBlit maskblit = MaskBlit.getFromCache(SurfaceType.IntArgbPre, sg.imageComp, dstType);
        /* NOTE: We can only use the native TransformHelper
             * func to go directly to the dest if both the helper
             * and the MaskBlit are native.
             * All helpers are native at this point, but some MaskBlit
             * objects are implemented in Java, so we need to check.
             */
        if (maskblit.getNativePrim() != 0) {
            // We can render directly.
            helper.Transform(maskblit, srcData, dstData, sg.composite, clip, itx, interpType, sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2, null, 0, 0);
            return;
        }
    }
    // We need to transform to a temp image and then copy
    // just the pieces that are valid data to the dest.
    final int w = dx2 - dx1;
    final int h = dy2 - dy1;
    BufferedImage tmpimg = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE);
    SurfaceData tmpData = SurfaceData.getPrimarySurfaceData(tmpimg);
    SurfaceType tmpType = tmpData.getSurfaceType();
    MaskBlit tmpmaskblit = MaskBlit.getFromCache(SurfaceType.IntArgbPre, CompositeType.SrcNoEa, tmpType);
    /*
         * The helper function fills a temporary edges buffer
         * for us with the bounding coordinates of each scanline
         * in the following format:
         *
         * edges[0, 1] = [top y, bottom y)
         * edges[2, 3] = [left x, right x) of top row
         * ...
         * edges[h*2, h*2+1] = [left x, right x) of bottom row
         *
         * all coordinates in the edges array will be relative to dx1, dy1
         *
         * edges thus has to be h*2+2 in length
         */
    final int[] edges = new int[h * 2 + 2];
    // It is important that edges[0]=edges[1]=0 when we call
    // Transform in case it must return early and we would
    // not want to render anything on an error condition.
    helper.Transform(tmpmaskblit, srcData, tmpData, AlphaComposite.Src, null, itx, interpType, sx1, sy1, sx2, sy2, 0, 0, w, h, edges, dx1, dy1);
    final Region region = Region.getInstance(dx1, dy1, dx2, dy2, edges);
    clip = clip.getIntersection(region);
    /* NOTE: We either have, or we can make,
         * a Blit for any composite type, even Custom
         */
    final Blit blit = Blit.getFromCache(tmpType, sg.imageComp, dstType);
    blit.Blit(tmpData, dstData, sg.composite, clip, 0, 0, dx1, dy1, w, h);
}

Example 10 with SurfaceType

use of sun.java2d.loops.SurfaceType in project jdk8u_jdk by JetBrains.

the class SurfaceData method getMaskFill.

/**
     * Returns a MaskFill object that can be used on this destination
     * with the source (paint) and composite types determined by the given
     * SunGraphics2D, or null if no such MaskFill object can be located.
     * Subclasses can override this method if they wish to filter other
     * attributes (such as the hardware capabilities of the destination
     * surface) before returning a specific MaskFill object.
     */
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    SurfaceType src = getPaintSurfaceType(sg2d);
    CompositeType comp = getFillCompositeType(sg2d);
    SurfaceType dst = getSurfaceType();
    return MaskFill.getFromCache(src, comp, dst);
}