1/*
2 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package sun.java2d.pipe;
27
28import java.awt.AlphaComposite;
29import java.awt.Composite;
30import sun.font.GlyphList;
31import sun.java2d.SunGraphics2D;
32import sun.java2d.SurfaceData;
33import static sun.java2d.pipe.BufferedOpCodes.*;
34
35import java.lang.annotation.Native;
36
37public abstract class BufferedTextPipe extends GlyphListPipe {
38
39    @Native private static final int BYTES_PER_GLYPH_IMAGE = 8;
40    @Native private static final int BYTES_PER_GLYPH_POSITION = 8;
41
42    /**
43     * The following offsets are used to pack the parameters in
44     * createPackedParams().  (They are also used at the native level when
45     * unpacking the params.)
46     */
47    @Native private static final int OFFSET_CONTRAST  = 8;
48    @Native private static final int OFFSET_RGBORDER  = 2;
49    @Native private static final int OFFSET_SUBPIXPOS = 1;
50    @Native private static final int OFFSET_POSITIONS = 0;
51
52    /**
53     * Packs the given parameters into a single int value in order to save
54     * space on the rendering queue.  Note that most of these parameters
55     * are only used for rendering LCD-optimized text, but conditionalizing
56     * this work wouldn't make any impact on performance, so we will pack
57     * those parameters even in the non-LCD case.
58     */
59    private static int createPackedParams(SunGraphics2D sg2d, GlyphList gl) {
60        return
61            (((gl.usePositions() ? 1 : 0)   << OFFSET_POSITIONS) |
62             ((gl.isSubPixPos()  ? 1 : 0)   << OFFSET_SUBPIXPOS) |
63             ((gl.isRGBOrder()   ? 1 : 0)   << OFFSET_RGBORDER ) |
64             ((sg2d.lcdTextContrast & 0xff) << OFFSET_CONTRAST ));
65    }
66
67    protected final RenderQueue rq;
68
69    protected BufferedTextPipe(RenderQueue rq) {
70        this.rq = rq;
71    }
72
73    @Override
74    protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {
75        /*
76         * The native drawGlyphList() only works with two composite types:
77         *    - CompositeType.SrcOver (with any extra alpha), or
78         *    - CompositeType.Xor
79         */
80        Composite comp = sg2d.composite;
81        if (comp == AlphaComposite.Src) {
82            /*
83             * In addition to the composite types listed above, the logic
84             * in OGL/D3DSurfaceData.validatePipe() allows for
85             * CompositeType.SrcNoEa, but only in the presence of an opaque
86             * color.  If we reach this case, we know the color is opaque,
87             * and therefore SrcNoEa is the same as SrcOverNoEa, so we
88             * override the composite here.
89             */
90            comp = AlphaComposite.SrcOver;
91        }
92
93        rq.lock();
94        try {
95            validateContext(sg2d, comp);
96            enqueueGlyphList(sg2d, gl);
97        } finally {
98            rq.unlock();
99        }
100    }
101
102    private void enqueueGlyphList(final SunGraphics2D sg2d,
103                                  final GlyphList gl)
104    {
105        // assert rq.lock.isHeldByCurrentThread();
106        RenderBuffer buf = rq.getBuffer();
107        final int totalGlyphs = gl.getNumGlyphs();
108        int glyphBytesRequired = totalGlyphs * BYTES_PER_GLYPH_IMAGE;
109        int posBytesRequired =
110            gl.usePositions() ? totalGlyphs * BYTES_PER_GLYPH_POSITION : 0;
111        int totalBytesRequired = 24 + glyphBytesRequired + posBytesRequired;
112
113        final long[] images = gl.getImages();
114        final float glyphListOrigX = gl.getX() + 0.5f;
115        final float glyphListOrigY = gl.getY() + 0.5f;
116
117        // make sure the RenderQueue keeps a hard reference to the FontStrike
118        // so that the associated glyph images are not disposed while enqueued
119        rq.addReference(gl.getStrike());
120
121        if (totalBytesRequired <= buf.capacity()) {
122            if (totalBytesRequired > buf.remaining()) {
123                // process the queue first and then enqueue the glyphs
124                rq.flushNow();
125            }
126            rq.ensureAlignment(20);
127            buf.putInt(DRAW_GLYPH_LIST);
128            // enqueue parameters
129            buf.putInt(totalGlyphs);
130            buf.putInt(createPackedParams(sg2d, gl));
131            buf.putFloat(glyphListOrigX);
132            buf.putFloat(glyphListOrigY);
133            // now enqueue glyph information
134            buf.put(images, 0, totalGlyphs);
135            if (gl.usePositions()) {
136                float[] positions = gl.getPositions();
137                buf.put(positions, 0, 2*totalGlyphs);
138            }
139        } else {
140            // queue is too small to accommodate glyphs; perform
141            // the operation directly on the queue flushing thread
142            rq.flushAndInvokeNow(new Runnable() {
143                public void run() {
144                    drawGlyphList(totalGlyphs, gl.usePositions(),
145                                  gl.isSubPixPos(), gl.isRGBOrder(),
146                                  sg2d.lcdTextContrast,
147                                  glyphListOrigX, glyphListOrigY,
148                                  images, gl.getPositions());
149                }
150            });
151        }
152    }
153
154    /**
155     * Called as a separate Runnable when the operation is too large to fit
156     * on the RenderQueue.  The OGL/D3D pipelines each have their own (small)
157     * native implementation of this method.
158     */
159    protected abstract void drawGlyphList(int numGlyphs, boolean usePositions,
160                                          boolean subPixPos, boolean rgbOrder,
161                                          int lcdContrast,
162                                          float glOrigX, float glOrigY,
163                                          long[] images, float[] positions);
164
165    /**
166     * Validates the state in the provided SunGraphics2D object.
167     */
168    protected abstract void validateContext(SunGraphics2D sg2d,
169                                            Composite comp);
170}
171