sun.java2d.loops.MaskFill Java Examples

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!OGLPaints.isValid(sg2d) ||
            !graphicsConfig.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) {
    if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
        /*
         * We can only accelerate non-Color MaskFill operations if
         * all of the following conditions hold true:
         *   - there is an implementation for the given paintState
         *   - the current Paint can be accelerated for this destination
         *   - multitexturing is available (since we need to modulate
         *     the alpha mask texture with the paint texture)
         *
         * In all other cases, we return null, in which case the
         * validation code will choose a more general software-based loop.
         */
        if (!D3DPaints.isValid(sg2d) ||
            !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE))
        {
            return null;
        }
    }
    return super.getMaskFill(sg2d);
}
 

@Override
public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
                     Composite comp,
                     final int x, final int y, final int w, final int h,
                     final byte[] mask,
                     final int maskoff, final int maskscan)
{
    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(sg2d, comp, BufferedContext.USE_MASK);

        // we adjust the mask length so that the mask ends on a
        // 4-byte boundary
        int maskBytesRequired;
        if (mask != null) {
            // we adjust the mask length so that the mask ends on a
            // 4-byte boundary
            maskBytesRequired = (mask.length + 3) & (~3);
        } else {
            // mask not needed
            maskBytesRequired = 0;
        }
        int totalBytesRequired = 32 + maskBytesRequired;

        RenderBuffer buf = rq.getBuffer();
        if (totalBytesRequired <= buf.capacity()) {
            if (totalBytesRequired > buf.remaining()) {
                // process the queue first and then enqueue the mask
                rq.flushNow();
            }

            buf.putInt(MASK_FILL);
            // enqueue parameters
            buf.putInt(x).putInt(y).putInt(w).putInt(h);
            buf.putInt(maskoff);
            buf.putInt(maskscan);
            buf.putInt(maskBytesRequired);
            if (mask != null) {
                // enqueue the mask
                int padding = maskBytesRequired - mask.length;
                buf.put(mask);
                if (padding != 0) {
                    buf.position(buf.position() + padding);
                }
            }
        } else {
            // queue is too small to accommodate entire mask; perform
            // the operation directly on the queue flushing thread
            rq.flushAndInvokeNow(new Runnable() {
                public void run() {
                    maskFill(x, y, w, h,
                             maskoff, maskscan, mask.length, mask);
                }
            });
        }
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
                     Composite comp,
                     final int x, final int y, final int w, final int h,
                     final byte[] mask,
                     final int maskoff, final int maskscan)
{
    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(sg2d, comp, BufferedContext.USE_MASK);

        // we adjust the mask length so that the mask ends on a
        // 4-byte boundary
        int maskBytesRequired;
        if (mask != null) {
            // we adjust the mask length so that the mask ends on a
            // 4-byte boundary
            maskBytesRequired = (mask.length + 3) & (~3);
        } else {
            // mask not needed
            maskBytesRequired = 0;
        }
        int totalBytesRequired = 32 + maskBytesRequired;

        RenderBuffer buf = rq.getBuffer();
        if (totalBytesRequired <= buf.capacity()) {
            if (totalBytesRequired > buf.remaining()) {
                // process the queue first and then enqueue the mask
                rq.flushNow();
            }

            buf.putInt(MASK_FILL);
            // enqueue parameters
            buf.putInt(x).putInt(y).putInt(w).putInt(h);
            buf.putInt(maskoff);
            buf.putInt(maskscan);
            buf.putInt(maskBytesRequired);
            if (mask != null) {
                // enqueue the mask
                int padding = maskBytesRequired - mask.length;
                buf.put(mask);
                if (padding != 0) {
                    buf.position(buf.position() + padding);
                }
            }
        } else {
            // queue is too small to accommodate entire mask; perform
            // the operation directly on the queue flushing thread
            rq.flushAndInvokeNow(new Runnable() {
                public void run() {
                    maskFill(x, y, w, h,
                             maskoff, maskscan, mask.length, mask);
                }
            });
        }
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
                     Composite comp,
                     final int x, final int y, final int w, final int h,
                     final byte[] mask,
                     final int maskoff, final int maskscan)
{
    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(sg2d, comp, BufferedContext.USE_MASK);

        // we adjust the mask length so that the mask ends on a
        // 4-byte boundary
        int maskBytesRequired;
        if (mask != null) {
            // we adjust the mask length so that the mask ends on a
            // 4-byte boundary
            maskBytesRequired = (mask.length + 3) & (~3);
        } else {
            // mask not needed
            maskBytesRequired = 0;
        }
        int totalBytesRequired = 32 + maskBytesRequired;

        RenderBuffer buf = rq.getBuffer();
        if (totalBytesRequired <= buf.capacity()) {
            if (totalBytesRequired > buf.remaining()) {
                // process the queue first and then enqueue the mask
                rq.flushNow();
            }

            buf.putInt(MASK_FILL);
            // enqueue parameters
            buf.putInt(x).putInt(y).putInt(w).putInt(h);
            buf.putInt(maskoff);
            buf.putInt(maskscan);
            buf.putInt(maskBytesRequired);
            if (mask != null) {
                // enqueue the mask
                int padding = maskBytesRequired - mask.length;
                buf.put(mask);
                if (padding != 0) {
                    buf.position(buf.position() + padding);
                }
            }
        } else {
            // queue is too small to accommodate entire mask; perform
            // the operation directly on the queue flushing thread
            rq.flushAndInvokeNow(new Runnable() {
                public void run() {
                    maskFill(x, y, w, h,
                             maskoff, maskscan, mask.length, mask);
                }
            });
        }
    } finally {
        rq.unlock();
    }
}