1/*
2 * Copyright (c) 2000, 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
26#include "jni_util.h"
27#include "jlong.h"
28
29#include "sun_java2d_loops_GraphicsPrimitiveMgr.h"
30
31#include "Region.h"
32#include "GraphicsPrimitiveMgr.h"
33#include "AlphaMacros.h"
34
35static char *InitName = "<init>";
36static char *InitSig =  ("(JLsun/java2d/loops/SurfaceType;"
37                         "Lsun/java2d/loops/CompositeType;"
38                         "Lsun/java2d/loops/SurfaceType;)V");
39
40static char *RegisterName =     "register";
41static char *RegisterSig =      "([Lsun/java2d/loops/GraphicsPrimitive;)V";
42
43static jclass GraphicsPrimitiveMgr;
44static jclass GraphicsPrimitive;
45
46static jmethodID RegisterID;
47static jfieldID pNativePrimID;
48static jfieldID pixelID;
49static jfieldID eargbID;
50static jfieldID clipRegionID;
51static jfieldID compositeID;
52static jfieldID lcdTextContrastID;
53static jfieldID xorPixelID;
54static jfieldID xorColorID;
55static jfieldID alphaMaskID;
56static jfieldID ruleID;
57static jfieldID extraAlphaID;
58
59static jfieldID m00ID;
60static jfieldID m01ID;
61static jfieldID m02ID;
62static jfieldID m10ID;
63static jfieldID m11ID;
64static jfieldID m12ID;
65
66static jmethodID getRgbID;
67
68static jboolean InitPrimTypes(JNIEnv *env);
69static jboolean InitSurfaceTypes(JNIEnv *env, jclass SurfaceType);
70static jboolean InitCompositeTypes(JNIEnv *env, jclass CompositeType);
71
72jfieldID path2DTypesID;
73jfieldID path2DNumTypesID;
74jfieldID path2DWindingRuleID;
75jfieldID path2DFloatCoordsID;
76jfieldID sg2dStrokeHintID;
77jint sunHints_INTVAL_STROKE_PURE;
78
79/*
80 * Class:     sun_java2d_loops_GraphicsPrimitiveMgr
81 * Method:    initIDs
82 * Signature: (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;)V
83 */
84JNIEXPORT void JNICALL
85Java_sun_java2d_loops_GraphicsPrimitiveMgr_initIDs
86    (JNIEnv *env, jclass GPMgr,
87     jclass GP, jclass ST, jclass CT,
88     jclass SG2D, jclass Color, jclass AT,
89     jclass XORComp, jclass AlphaComp,
90     jclass Path2D, jclass Path2DFloat,
91     jclass SHints)
92{
93    jfieldID fid;
94    initAlphaTables();
95    GraphicsPrimitiveMgr = (*env)->NewGlobalRef(env, GPMgr);
96    GraphicsPrimitive = (*env)->NewGlobalRef(env, GP);
97    if (GraphicsPrimitiveMgr == NULL || GraphicsPrimitive == NULL) {
98        JNU_ThrowOutOfMemoryError(env, "creating global refs");
99        return;
100    }
101    if (!InitPrimTypes(env) ||
102        !InitSurfaceTypes(env, ST) ||
103        !InitCompositeTypes(env, CT))
104    {
105        return;
106    }
107    CHECK_NULL(RegisterID =
108        (*env)->GetStaticMethodID(env, GPMgr, RegisterName, RegisterSig));
109    CHECK_NULL(pNativePrimID = (*env)->GetFieldID(env, GP, "pNativePrim", "J"));
110    CHECK_NULL(pixelID = (*env)->GetFieldID(env, SG2D, "pixel", "I"));
111    CHECK_NULL(eargbID = (*env)->GetFieldID(env, SG2D, "eargb", "I"));
112    CHECK_NULL(clipRegionID =
113        (*env)->GetFieldID(env, SG2D, "clipRegion", "Lsun/java2d/pipe/Region;"));
114    CHECK_NULL(compositeID =
115        (*env)->GetFieldID(env, SG2D, "composite", "Ljava/awt/Composite;"));
116    CHECK_NULL(lcdTextContrastID =
117        (*env)->GetFieldID(env, SG2D, "lcdTextContrast", "I"));
118    CHECK_NULL(getRgbID = (*env)->GetMethodID(env, Color, "getRGB", "()I"));
119    CHECK_NULL(xorPixelID = (*env)->GetFieldID(env, XORComp, "xorPixel", "I"));
120    CHECK_NULL(xorColorID =
121        (*env)->GetFieldID(env, XORComp, "xorColor", "Ljava/awt/Color;"));
122    CHECK_NULL(alphaMaskID =
123        (*env)->GetFieldID(env, XORComp, "alphaMask", "I"));
124    CHECK_NULL(ruleID = (*env)->GetFieldID(env, AlphaComp, "rule", "I"));
125    CHECK_NULL(extraAlphaID =
126        (*env)->GetFieldID(env, AlphaComp, "extraAlpha", "F"));
127
128
129    CHECK_NULL(m00ID = (*env)->GetFieldID(env, AT, "m00", "D"));
130    CHECK_NULL(m01ID = (*env)->GetFieldID(env, AT, "m01", "D"));
131    CHECK_NULL(m02ID = (*env)->GetFieldID(env, AT, "m02", "D"));
132    CHECK_NULL(m10ID = (*env)->GetFieldID(env, AT, "m10", "D"));
133    CHECK_NULL(m11ID = (*env)->GetFieldID(env, AT, "m11", "D"));
134    CHECK_NULL(m12ID = (*env)->GetFieldID(env, AT, "m12", "D"));
135
136    CHECK_NULL(path2DTypesID =
137        (*env)->GetFieldID(env, Path2D, "pointTypes", "[B"));
138    CHECK_NULL(path2DNumTypesID =
139        (*env)->GetFieldID(env, Path2D, "numTypes", "I"));
140    CHECK_NULL(path2DWindingRuleID =
141        (*env)->GetFieldID(env, Path2D, "windingRule", "I"));
142    CHECK_NULL(path2DFloatCoordsID =
143        (*env)->GetFieldID(env, Path2DFloat, "floatCoords", "[F"));
144    CHECK_NULL(sg2dStrokeHintID =
145        (*env)->GetFieldID(env, SG2D, "strokeHint", "I"));
146    CHECK_NULL(fid =
147        (*env)->GetStaticFieldID(env, SHints, "INTVAL_STROKE_PURE", "I"));
148    sunHints_INTVAL_STROKE_PURE = (*env)->GetStaticIntField(env, SHints, fid);
149}
150
151void GrPrim_RefineBounds(SurfaceDataBounds *bounds, jint transX, jint transY,
152                         jfloat *coords,  jint maxCoords)
153{
154    jint xmin, ymin, xmax, ymax;
155    if (maxCoords > 1) {
156        xmin = xmax = transX + (jint)(*coords++ + 0.5);
157        ymin = ymax = transY + (jint)(*coords++ + 0.5);
158        for (;maxCoords > 1; maxCoords -= 2) {
159            jint x = transX + (jint)(*coords++ + 0.5);
160            jint y = transY + (jint)(*coords++ + 0.5);
161            if (xmin > x) xmin = x;
162            if (ymin > y) ymin = y;
163            if (xmax < x) xmax = x;
164            if (ymax < y) ymax = y;
165        }
166        if (++xmax < xmin) xmax--;
167        if (++ymax < ymin) ymax--;
168        if (bounds->x1 < xmin) bounds->x1 = xmin;
169        if (bounds->y1 < ymin) bounds->y1 = ymin;
170        if (bounds->x2 > xmax) bounds->x2 = xmax;
171        if (bounds->y2 > ymax) bounds->y2 = ymax;
172    } else {
173        bounds->x2 = bounds->x1;
174        bounds->y2 = bounds->y1;
175    }
176}
177
178/*
179 * Class:     sun_java2d_loops_GraphicsPrimitiveMgr
180 * Method:    registerNativeLoops
181 * Signature: ()V
182 */
183JNIEXPORT void JNICALL
184Java_sun_java2d_loops_GraphicsPrimitiveMgr_registerNativeLoops
185    (JNIEnv *env, jclass GPMgr)
186{
187    RegisterFunc RegisterAnyByte;
188    RegisterFunc RegisterByteBinary1Bit;
189    RegisterFunc RegisterByteBinary2Bit;
190    RegisterFunc RegisterByteBinary4Bit;
191    RegisterFunc RegisterByteIndexed;
192    RegisterFunc RegisterByteGray;
193    RegisterFunc RegisterIndex8Gray;
194    RegisterFunc RegisterIndex12Gray;
195    RegisterFunc RegisterAnyShort;
196    RegisterFunc RegisterUshort555Rgb;
197    RegisterFunc RegisterUshort565Rgb;
198    RegisterFunc RegisterUshort4444Argb;
199    RegisterFunc RegisterUshort555Rgbx;
200    RegisterFunc RegisterUshortGray;
201    RegisterFunc RegisterUshortIndexed;
202    RegisterFunc RegisterAny3Byte;
203    RegisterFunc RegisterThreeByteBgr;
204    RegisterFunc RegisterAnyInt;
205    RegisterFunc RegisterIntArgb;
206    RegisterFunc RegisterIntArgbPre;
207    RegisterFunc RegisterIntArgbBm;
208    RegisterFunc RegisterIntRgb;
209    RegisterFunc RegisterIntBgr;
210    RegisterFunc RegisterIntRgbx;
211    RegisterFunc RegisterAny4Byte;
212    RegisterFunc RegisterFourByteAbgr;
213    RegisterFunc RegisterFourByteAbgrPre;
214
215    if (!RegisterAnyByte(env) ||
216        !RegisterByteBinary1Bit(env) ||
217        !RegisterByteBinary2Bit(env) ||
218        !RegisterByteBinary4Bit(env) ||
219        !RegisterByteIndexed(env) ||
220        !RegisterByteGray(env) ||
221        !RegisterIndex8Gray(env) ||
222        !RegisterIndex12Gray(env) ||
223        !RegisterAnyShort(env) ||
224        !RegisterUshort555Rgb(env) ||
225        !RegisterUshort565Rgb(env) ||
226        !RegisterUshort4444Argb(env) ||
227        !RegisterUshort555Rgbx(env) ||
228        !RegisterUshortGray(env) ||
229        !RegisterUshortIndexed(env) ||
230        !RegisterAny3Byte(env) ||
231        !RegisterThreeByteBgr(env) ||
232        !RegisterAnyInt(env) ||
233        !RegisterIntArgb(env) ||
234        !RegisterIntArgbPre(env) ||
235        !RegisterIntArgbBm(env) ||
236        !RegisterIntRgb(env) ||
237        !RegisterIntBgr(env) ||
238        !RegisterIntRgbx(env) ||
239        !RegisterAny4Byte(env) ||
240        !RegisterFourByteAbgr(env) ||
241        !RegisterFourByteAbgrPre(env))
242    {
243        return;
244    }
245}
246
247#define _StartOf(T)     ((T *) (&T##s))
248#define _NumberOf(T)    (sizeof(T##s) / sizeof(T))
249#define _EndOf(T)       (_StartOf(T) + _NumberOf(T))
250
251#define PrimTypeStart   _StartOf(PrimitiveType)
252#define PrimTypeEnd     _EndOf(PrimitiveType)
253
254#define SurfTypeStart   _StartOf(SurfaceType)
255#define SurfTypeEnd     _EndOf(SurfaceType)
256
257#define CompTypeStart   _StartOf(CompositeType)
258#define CompTypeEnd     _EndOf(CompositeType)
259
260/*
261 * This function initializes the global collection of PrimitiveType
262 * structures by retrieving the necessary Java Class object and the
263 * associated methodID of the necessary constructor.
264 *
265 * See PrimitiveTypes.* below.
266 */
267static jboolean InitPrimTypes(JNIEnv *env)
268{
269    jboolean ok = JNI_TRUE;
270    PrimitiveType *pPrimType;
271    jclass cl;
272
273    for (pPrimType = PrimTypeStart; pPrimType < PrimTypeEnd; pPrimType++) {
274        cl = (*env)->FindClass(env, pPrimType->ClassName);
275        if (cl == NULL) {
276            ok = JNI_FALSE;
277            break;
278        }
279        pPrimType->ClassObject = (*env)->NewGlobalRef(env, cl);
280        pPrimType->Constructor =
281            (*env)->GetMethodID(env, cl, InitName, InitSig);
282
283        (*env)->DeleteLocalRef(env, cl);
284        if (pPrimType->ClassObject == NULL ||
285            pPrimType->Constructor == NULL)
286        {
287            ok = JNI_FALSE;
288            break;
289        }
290    }
291
292    if (!ok) {
293        for (pPrimType = PrimTypeStart; pPrimType < PrimTypeEnd; pPrimType++) {
294            if (pPrimType->ClassObject != NULL) {
295                (*env)->DeleteGlobalRef(env, pPrimType->ClassObject);
296                pPrimType->ClassObject = NULL;
297            }
298            pPrimType->Constructor = NULL;
299        }
300    }
301
302    return ok;
303}
304
305/*
306 * This function initializes the global collection of SurfaceType
307 * or CompositeType structures by retrieving the corresponding Java
308 * object stored as a static field on the Java Class.
309 *
310 * See SurfaceTypes.* below.
311 * See CompositeeTypes.* below.
312 */
313static jboolean InitSimpleTypes
314    (JNIEnv *env, jclass SimpleClass, char *SimpleSig,
315     SurfCompHdr *pStart, SurfCompHdr *pEnd, jsize size)
316{
317    jboolean ok = JNI_TRUE;
318    SurfCompHdr *pHdr;
319    jfieldID field;
320    jobject obj;
321
322    for (pHdr = pStart; pHdr < pEnd; pHdr = PtrAddBytes(pHdr, size)) {
323        field = (*env)->GetStaticFieldID(env,
324                                         SimpleClass,
325                                         pHdr->Name,
326                                         SimpleSig);
327        if (field == NULL) {
328            ok = JNI_FALSE;
329            break;
330        }
331        obj = (*env)->GetStaticObjectField(env, SimpleClass, field);
332        if (obj == NULL) {
333            ok = JNI_FALSE;
334            break;
335        }
336        pHdr->Object = (*env)->NewGlobalRef(env, obj);
337        (*env)->DeleteLocalRef(env, obj);
338        if (pHdr->Object == NULL) {
339            ok = JNI_FALSE;
340            break;
341        }
342    }
343
344    if (!ok) {
345        for (pHdr = pStart; pHdr < pEnd; pHdr = PtrAddBytes(pHdr, size)) {
346            if (pHdr->Object != NULL) {
347                (*env)->DeleteGlobalRef(env, pHdr->Object);
348                pHdr->Object = NULL;
349            }
350        }
351    }
352
353    return ok;
354}
355
356static jboolean InitSurfaceTypes(JNIEnv *env, jclass ST)
357{
358    return InitSimpleTypes(env, ST, "Lsun/java2d/loops/SurfaceType;",
359                           (SurfCompHdr *) SurfTypeStart,
360                           (SurfCompHdr *) SurfTypeEnd,
361                           sizeof(SurfaceType));
362}
363
364static jboolean InitCompositeTypes(JNIEnv *env, jclass CT)
365{
366    return InitSimpleTypes(env, CT, "Lsun/java2d/loops/CompositeType;",
367                           (SurfCompHdr *) CompTypeStart,
368                           (SurfCompHdr *) CompTypeEnd,
369                           sizeof(CompositeType));
370}
371
372/*
373 * This function registers a set of Java GraphicsPrimitive objects
374 * based on information stored in an array of NativePrimitive structures.
375 */
376jboolean RegisterPrimitives(JNIEnv *env,
377                            NativePrimitive *pPrim,
378                            jint NumPrimitives)
379{
380    jarray primitives;
381    int i;
382
383    primitives = (*env)->NewObjectArray(env, NumPrimitives,
384                                        GraphicsPrimitive, NULL);
385    if (primitives == NULL) {
386        return JNI_FALSE;
387    }
388
389    for (i = 0; i < NumPrimitives; i++, pPrim++) {
390        jint srcflags, dstflags;
391        jobject prim;
392        PrimitiveType *pType = pPrim->pPrimType;
393        SurfaceType *pSrc = pPrim->pSrcType;
394        CompositeType *pComp = pPrim->pCompType;
395        SurfaceType *pDst = pPrim->pDstType;
396
397        pPrim->funcs.initializer = MapAccelFunction(pPrim->funcs_c.initializer);
398
399        /*
400         * Calculate the necessary SurfaceData lock flags for the
401         * source and destination surfaces based on the information
402         * stored in the PrimitiveType, SurfaceType, and CompositeType
403         * structures.  The starting point is the values that are
404         * already stored in the NativePrimitive structure.  These
405         * flags are usually left as 0, but can be filled in by
406         * native primitive loops that have special needs that are
407         * not deducible from their declared attributes.
408         */
409        srcflags = pPrim->srcflags;
410        dstflags = pPrim->dstflags;
411        srcflags |= pType->srcflags;
412        dstflags |= pType->dstflags;
413        dstflags |= pComp->dstflags;
414        if (srcflags & SD_LOCK_READ) srcflags |= pSrc->readflags;
415        /* if (srcflags & SD_LOCK_WRITE) srcflags |= pSrc->writeflags; */
416        if (dstflags & SD_LOCK_READ) dstflags |= pDst->readflags;
417        if (dstflags & SD_LOCK_WRITE) dstflags |= pDst->writeflags;
418        pPrim->srcflags = srcflags;
419        pPrim->dstflags = dstflags;
420
421        prim = (*env)->NewObject(env,
422                                 pType->ClassObject,
423                                 pType->Constructor,
424                                 ptr_to_jlong(pPrim),
425                                 pSrc->hdr.Object,
426                                 pComp->hdr.Object,
427                                 pDst->hdr.Object);
428        if (prim == NULL) {
429            break;
430        }
431        (*env)->SetObjectArrayElement(env, primitives, i, prim);
432        (*env)->DeleteLocalRef(env, prim);
433        if ((*env)->ExceptionCheck(env)) {
434            break;
435        }
436    }
437
438    if (i >= NumPrimitives) {
439        /* No error - upcall to GraphicsPrimitiveMgr to register the
440         * new primitives... */
441        (*env)->CallStaticVoidMethod(env, GraphicsPrimitiveMgr, RegisterID,
442                                     primitives);
443    }
444    (*env)->DeleteLocalRef(env, primitives);
445
446    return !((*env)->ExceptionCheck(env));
447}
448
449JNIEXPORT NativePrimitive * JNICALL
450GetNativePrim(JNIEnv *env, jobject gp)
451{
452    NativePrimitive *pPrim;
453
454    pPrim = (NativePrimitive *) JNU_GetLongFieldAsPtr(env, gp, pNativePrimID);
455    if (pPrim == NULL) {
456        JNU_ThrowInternalError(env, "Non-native Primitive invoked natively");
457    }
458
459    return pPrim;
460}
461
462JNIEXPORT void JNICALL
463GrPrim_Sg2dGetCompInfo(JNIEnv *env, jobject sg2d,
464                       NativePrimitive *pPrim, CompositeInfo *pCompInfo)
465{
466    jobject comp;
467
468    comp = (*env)->GetObjectField(env, sg2d, compositeID);
469    (*pPrim->pCompType->getCompInfo)(env, pCompInfo, comp);
470    (*env)->DeleteLocalRef(env, comp);
471}
472
473JNIEXPORT jint JNICALL
474GrPrim_CompGetXorColor(JNIEnv *env, jobject comp)
475{
476    jobject color;
477    jint rgb;
478
479    color = (*env)->GetObjectField(env, comp, xorColorID);
480    rgb = (*env)->CallIntMethod(env, color, getRgbID);
481    (*env)->DeleteLocalRef(env, color);
482
483    return rgb;
484}
485
486JNIEXPORT void JNICALL
487GrPrim_Sg2dGetClip(JNIEnv *env, jobject sg2d, SurfaceDataBounds *bounds)
488{
489    jobject clip = (*env)->GetObjectField(env, sg2d, clipRegionID);
490    Region_GetBounds(env, clip, bounds);
491}
492
493JNIEXPORT jint JNICALL
494GrPrim_Sg2dGetPixel(JNIEnv *env, jobject sg2d)
495{
496    return (*env)->GetIntField(env, sg2d, pixelID);
497}
498
499JNIEXPORT jint JNICALL
500GrPrim_Sg2dGetEaRGB(JNIEnv *env, jobject sg2d)
501{
502    return (*env)->GetIntField(env, sg2d, eargbID);
503}
504
505JNIEXPORT jint JNICALL
506GrPrim_Sg2dGetLCDTextContrast(JNIEnv *env, jobject sg2d)
507{
508    return (*env)->GetIntField(env, sg2d, lcdTextContrastID);
509}
510
511/*
512 * Helper function for CompositeTypes.Xor
513 */
514JNIEXPORT void JNICALL
515GrPrim_CompGetXorInfo(JNIEnv *env, CompositeInfo *pCompInfo, jobject comp)
516{
517    pCompInfo->rule = RULE_Xor;
518    pCompInfo->details.xorPixel = (*env)->GetIntField(env, comp, xorPixelID);
519    pCompInfo->alphaMask = (*env)->GetIntField(env, comp, alphaMaskID);
520}
521
522/*
523 * Helper function for CompositeTypes.AnyAlpha
524 */
525JNIEXPORT void JNICALL
526GrPrim_CompGetAlphaInfo(JNIEnv *env, CompositeInfo *pCompInfo, jobject comp)
527{
528    pCompInfo->rule =
529        (*env)->GetIntField(env, comp, ruleID);
530    pCompInfo->details.extraAlpha =
531        (*env)->GetFloatField(env, comp, extraAlphaID);
532}
533
534JNIEXPORT void JNICALL
535Transform_GetInfo(JNIEnv *env, jobject txform, TransformInfo *pTxInfo)
536{
537    pTxInfo->dxdx = (*env)->GetDoubleField(env, txform, m00ID);
538    pTxInfo->dxdy = (*env)->GetDoubleField(env, txform, m01ID);
539    pTxInfo->tx   = (*env)->GetDoubleField(env, txform, m02ID);
540    pTxInfo->dydx = (*env)->GetDoubleField(env, txform, m10ID);
541    pTxInfo->dydy = (*env)->GetDoubleField(env, txform, m11ID);
542    pTxInfo->ty   = (*env)->GetDoubleField(env, txform, m12ID);
543}
544
545JNIEXPORT void JNICALL
546Transform_transform(TransformInfo *pTxInfo, jdouble *pX, jdouble *pY)
547{
548    jdouble x = *pX;
549    jdouble y = *pY;
550
551    *pX = pTxInfo->dxdx * x + pTxInfo->dxdy * y + pTxInfo->tx;
552    *pY = pTxInfo->dydx * x + pTxInfo->dydy * y + pTxInfo->ty;
553}
554
555/*
556 * External declarations for the pixelFor helper methods for the various
557 * named surface types.  These functions are defined in the various
558 * files that contain the loop functions for their type.
559 */
560extern PixelForFunc PixelForByteBinary;
561extern PixelForFunc PixelForByteIndexed;
562extern PixelForFunc PixelForByteGray;
563extern PixelForFunc PixelForIndex8Gray;
564extern PixelForFunc PixelForIndex12Gray;
565extern PixelForFunc PixelForUshort555Rgb;
566extern PixelForFunc PixelForUshort555Rgbx;
567extern PixelForFunc PixelForUshort565Rgb;
568extern PixelForFunc PixelForUshort4444Argb;
569extern PixelForFunc PixelForUshortGray;
570extern PixelForFunc PixelForUshortIndexed;
571extern PixelForFunc PixelForIntArgbPre;
572extern PixelForFunc PixelForIntArgbBm;
573extern PixelForFunc PixelForIntBgr;
574extern PixelForFunc PixelForIntRgbx;
575extern PixelForFunc PixelForFourByteAbgr;
576extern PixelForFunc PixelForFourByteAbgrPre;
577
578/*
579 * Definition and initialization of the globally accessible PrimitiveTypes.
580 */
581struct _PrimitiveTypes PrimitiveTypes = {
582    { "sun/java2d/loops/Blit", SD_LOCK_READ, SD_LOCK_WRITE, NULL, NULL},
583    { "sun/java2d/loops/BlitBg", SD_LOCK_READ, SD_LOCK_WRITE, NULL, NULL},
584    { "sun/java2d/loops/ScaledBlit", SD_LOCK_READ, SD_LOCK_WRITE, NULL, NULL},
585    { "sun/java2d/loops/FillRect", 0, SD_LOCK_WRITE, NULL, NULL},
586    { "sun/java2d/loops/FillSpans", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
587    { "sun/java2d/loops/FillParallelogram", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
588    { "sun/java2d/loops/DrawParallelogram", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
589    { "sun/java2d/loops/DrawLine", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
590    { "sun/java2d/loops/DrawRect", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
591    { "sun/java2d/loops/DrawPolygons", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
592    { "sun/java2d/loops/DrawPath", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
593    { "sun/java2d/loops/FillPath", 0, SD_LOCK_PARTIAL_WRITE, NULL, NULL},
594    { "sun/java2d/loops/MaskBlit", SD_LOCK_READ, SD_LOCK_RD_WR, NULL, NULL},
595    { "sun/java2d/loops/MaskFill", 0, SD_LOCK_RD_WR, NULL, NULL},
596    { "sun/java2d/loops/DrawGlyphList", 0, SD_LOCK_PARTIAL_WRITE |
597                                           SD_LOCK_FASTEST, NULL, NULL},
598    { "sun/java2d/loops/DrawGlyphListAA", 0, SD_LOCK_RD_WR | SD_LOCK_FASTEST, NULL, NULL},
599    { "sun/java2d/loops/DrawGlyphListLCD", 0, SD_LOCK_RD_WR | SD_LOCK_FASTEST, NULL, NULL},
600    { "sun/java2d/loops/TransformHelper", SD_LOCK_READ, 0, NULL, NULL}
601};
602
603/*
604 * Definition and initialization of the globally accessible SurfaceTypes.
605 */
606struct _SurfaceTypes SurfaceTypes = {
607    { { "OpaqueColor", NULL}, NULL, 0, 0 },
608    { { "AnyColor", NULL}, NULL, 0, 0 },
609    { { "AnyByte", NULL}, NULL, 0, 0 },
610    { { "ByteBinary1Bit", NULL},
611      PixelForByteBinary, SD_LOCK_LUT, SD_LOCK_INVCOLOR },
612    { { "ByteBinary2Bit", NULL},
613      PixelForByteBinary, SD_LOCK_LUT, SD_LOCK_INVCOLOR },
614    { { "ByteBinary4Bit", NULL},
615      PixelForByteBinary, SD_LOCK_LUT, SD_LOCK_INVCOLOR },
616    { { "ByteIndexed", NULL},
617      PixelForByteIndexed, SD_LOCK_LUT, SD_LOCK_INVCOLOR },
618    { { "ByteIndexedBm", NULL},
619      PixelForByteIndexed, SD_LOCK_LUT, SD_LOCK_INVCOLOR },
620    { { "ByteGray", NULL}, PixelForByteGray, 0, 0},
621    { { "Index8Gray", NULL},
622      PixelForIndex8Gray, SD_LOCK_LUT, SD_LOCK_INVGRAY },
623    { { "Index12Gray", NULL},
624      PixelForIndex12Gray, SD_LOCK_LUT, SD_LOCK_INVGRAY },
625    { { "AnyShort", NULL}, NULL, 0, 0 },
626    { { "Ushort555Rgb", NULL}, PixelForUshort555Rgb, 0, 0},
627    { { "Ushort555Rgbx", NULL}, PixelForUshort555Rgbx, 0, 0},
628    { { "Ushort565Rgb", NULL}, PixelForUshort565Rgb, 0, 0 },
629    { { "Ushort4444Argb", NULL}, PixelForUshort4444Argb, 0, 0 },
630    { { "UshortGray", NULL}, PixelForUshortGray, 0, 0},
631    { { "UshortIndexed", NULL},
632      PixelForUshortIndexed, SD_LOCK_LUT, SD_LOCK_INVCOLOR },
633    { { "Any3Byte", NULL},  NULL, 0, 0 },
634    { { "ThreeByteBgr", NULL},  NULL, 0, 0 },
635    { { "AnyInt", NULL}, NULL, 0, 0 },
636    { { "IntArgb", NULL},  NULL, 0, 0 },
637    { { "IntArgbPre", NULL}, PixelForIntArgbPre, 0, 0},
638    { { "IntArgbBm", NULL}, PixelForIntArgbBm, 0, 0},
639    { { "IntRgb", NULL},  NULL, 0, 0 },
640    { { "IntBgr", NULL}, PixelForIntBgr, 0, 0},
641    { { "IntRgbx", NULL}, PixelForIntRgbx, 0, 0},
642    { { "Any4Byte", NULL},  NULL, 0, 0 },
643    { { "FourByteAbgr", NULL}, PixelForFourByteAbgr, 0, 0},
644    { { "FourByteAbgrPre", NULL}, PixelForFourByteAbgrPre, 0, 0},
645};
646
647/*
648 * Definition and initialization of the globally accessible CompositeTypes.
649 */
650struct _CompositeTypes CompositeTypes = {
651    { { "SrcNoEa", NULL}, NULL, 0},
652    { { "SrcOverNoEa", NULL}, NULL, SD_LOCK_RD_WR },
653    { { "SrcOverNoEa", NULL}, NULL, SD_LOCK_PARTIAL_WRITE }, /* SrcOverBmNoEa */
654    { { "Src", NULL}, GrPrim_CompGetAlphaInfo, 0},
655    { { "SrcOver", NULL}, GrPrim_CompGetAlphaInfo, SD_LOCK_RD_WR },
656    { { "Xor", NULL}, GrPrim_CompGetXorInfo, SD_LOCK_RD_WR },
657    { { "AnyAlpha", NULL}, GrPrim_CompGetAlphaInfo, SD_LOCK_RD_WR },
658};
659