/*
* Class: sun_dc_pr_PathStroker
* Method: setPenT4
* Signature: ([F)V
*/
JNIEXPORT void JNICALL Java_sun_dc_pr_PathStroker_setPenT4
(JNIEnv *env, jobject obj, jfloatArray t4)
{
PathStroker cdata = (PathStroker)jlong_to_ptr(((*env)->GetLongField(env, obj, fidCData)));
doeE cenv = cdata->env;
doeE_setPCtxt(cenv, env);
doeError_reset(cenv);
if (t4 == NULL) {
(*cdata->stroker)->setPenT4(cenv, cdata->stroker, NULL);
} else {
jfloat* ct4;
if (((*env)->GetArrayLength(env, t4)) < 4) {
doeError_set(cenv, dcPRError, dcPRError_BAD_pent4);
CJError_throw(cenv);
return;
}
ct4 = (*env)->GetPrimitiveArrayCritical(env, t4, NULL);
(*cdata->stroker)->setPenT4(cenv, cdata->stroker, (f32*)ct4);
(*env)->ReleasePrimitiveArrayCritical(env, t4, ct4, JNI_ABORT);
}
if (doeError_occurred(cenv))
CJError_throw(cenv);
}
static void
useProxy(doeE env, dcPathConsumer pc, dcFastPathProducer proxy)
{
dcPathFillerData* p = (dcPathFillerData*)pc;
dcFastPathProducer fpp = p->thisFPP;
((dcPathConsumerFace*)&dcPathStoreClass)->useProxy(env, pc, proxy);
if (doeError_occurred(env)) return;
(*proxy)->getBox(env, proxy, p->pathBox);
if (doeError_occurred(env)) return;
#ifdef DEBUG
/*
* Set the exception to indicate that some segments of the path have
* way too large coordinates. The exception will be eaten at java level.
* See 4485298 for more info.
*/
if (!( dcPathFiller_validLoCoord(p->pathBox[0]) &&
dcPathFiller_validLoCoord(p->pathBox[1]) &&
dcPathFiller_validHiCoord(p->pathBox[2]) &&
dcPathFiller_validHiCoord(p->pathBox[3]))) {
doeError_set(env, dcPathException, dcPathException_BAD_PATH_useProxy);
}
#endif
}
/*
* Class: sun_dc_pr_PathDasher
* Method: setOutputT6
* Signature: ([F)V
*/
JNIEXPORT void JNICALL Java_sun_dc_pr_PathDasher_setOutputT6
(JNIEnv *env, jobject obj, jfloatArray t6)
{
PathDasher cdata = (PathDasher)jlong_to_ptr(((*env)->GetLongField(env, obj, fidCData)));
doeE cenv = cdata->env;
doeE_setPCtxt(cenv, env);
doeError_reset(cenv);
if (t6 == NULL) {
(*cdata->dasher)->setOutputT6(cenv, cdata->dasher, NULL);
} else {
jfloat* ct6;
if (((*env)->GetArrayLength(env, t6)) < 6) {
doeError_set(cenv, dcPRError, dcPRError_BAD_outputt6);
CJError_throw(cenv);
return;
}
ct6 = (*env)->GetPrimitiveArrayCritical(env, t6, NULL);
(*cdata->dasher)->setOutputT6(cenv, cdata->dasher, (f32*)ct6);
(*env)->ReleasePrimitiveArrayCritical(env, t6, ct6, JNI_ABORT);
}
if (doeError_occurred(cenv))
CJError_throw(cenv);
}
static void
setFillMode(doeE env, dcPathFiller pf, ixx fillmode)
{
dcPathFillerData* p = (dcPathFillerData*)pf;
if (stateCheck(p, setFillModeDone)) {
doeError_set(env, dcPRError, dcPRError_UNEX_setUsage);
return;
}
if (fillmode != dcPathFiller_NZFILL && fillmode != dcPathFiller_EOFILL) {
doeError_set(env, dcPRError, dcPRError_UNK_fillmode);
return;
}
p->redundantReset = FALSE;
p->fillmode = fillmode;
stateSet(p, setFillModeDone);
}
static void
writeAlpha16( doeE env, dcPathFiller pf,
u16* alpha, i32 xstride, i32 ystride, i32 pix0offset)
{
dcPathFillerData* p = (dcPathFillerData*)pf;
dcLLFiller ll;
if (!stateCheck(p, setOutputAreaDone)) {
doeError_set(env, dcPRError, dcPRError_UNEX_writeAlpha);
return;
}
if (alpha == NULL || xstride <= 0 || ystride <= 0 || pix0offset < 0) {
doeError_set(env, dcPRError, dcPRError_BAD_alphadest);
return;
}
ll = dcLLFiller_get(env);
if (doeError_occurred(env))
return;
if (p->fastOutput) {
FastOutputPC fopc = p->fastOutputPC;
dcFastPathProducer fpp = p->thisFPP;
(*ll)->setParams(env, ll, p->fillmode, p->outW, p->outH);
(*fopc)->setUpAlpha16( env, fopc, ll,
-p->outLoX, -p->outLoY,
alpha, xstride, ystride, pix0offset);
(*fpp)->sendTo(env, fpp, (dcPathConsumer)fopc);
} else {
i32 tilew = MIN(p->outW - ((p->tileXI - 1) << dcPathFiller_tileSizeL2S),
dcPathFiller_tileSize);
(*ll)->setParams(env, ll, p->fillmode, tilew, p->rowH);
sendTileToLLFiller(env, pf, ll);
(*ll)->writeAlpha16(env, ll, alpha, xstride, ystride, pix0offset);
}
dcLLFiller_release(env, ll);
nextTile(env,pf);
}
static void
getAlphaBox(doeE env, dcPathFiller pf, i32* box)
{
dcPathFillerData* p = (dcPathFillerData*)pf;
if (!((dcPathStoreData*)p)->pathDefined) {
doeError_set(env, dcPRError, dcPRError_UNEX_getAlphaBox);
return;
}
box[0] = (i32)floor(p->pathBox[0]);
box[1] = (i32)floor(p->pathBox[1]);
box[2] = (i32)ceil (p->pathBox[2]);
box[3] = (i32)ceil (p->pathBox[3]);
}
static ixx
getTileState(doeE env, dcPathFiller pf)
{
dcPathFillerData* p = (dcPathFillerData*)pf;
Run r;
ixx lscount;
LeftSide ls;
if (!stateCheck(p, setOutputAreaDone)) {
doeError_set(env, dcPRError, dcPRError_UNEX_getTileState);
return -1;
}
/* "fast output" situations are never trivial */
if (p->fastOutput) {
return dcPathFiller_TILE_IS_GENERAL;
}
/* two conditions must be met for a tile to be trivial:
1. the tile itself must contain no runs
2. the list lsEffects must consist exclusively of
"full height" left sides
*/
r = p->tileRuns[p->tileXI][p->tileYI];
if (r != NULL) {
return dcPathFiller_TILE_IS_GENERAL;
}
lscount = 0;
for (ls = p->lsEffects; ls != NULL; ls = ls->next) {
if (ls->y0 == 0.0F && ls->y1 == p->rowHTiF) {
lscount++;
continue;
}
if (ls->y1 == 0.0F && ls->y0 == p->rowHTiF) {
lscount--;
continue;
}
return dcPathFiller_TILE_IS_GENERAL;
}
if (p->fillmode == dcPathFiller_EOFILL)
lscount &= 1;
return (lscount != 0)?
dcPathFiller_TILE_IS_ALL_1 :
dcPathFiller_TILE_IS_ALL_0;
}
static void
nextTile(doeE env, dcPathFiller pf)
{
dcPathFillerData* p = (dcPathFillerData*)pf;
if (!stateCheck(p, setOutputAreaDone)) {
doeError_set(env, dcPRError, dcPRError_UNEX_nextTile);
return;
}
if (p->fastOutput) {
stateReset(p, setOutputAreaDone);
return;
}
/* advance x tile index */
p->tileXI++;
if (p->tileXI > p->outWTi) { /* tileXI in [1, outWITi] */
/* clear left side effects */
LeftSide_releaseList(env, p->lsEffects);
p->lsEffects = NULL;
p->tileXI = 1; /* 0 is left-open tile */
p->tileYI++;
if (p->tileYI >= p->outHTi) {
stateReset(p, setOutputAreaDone);
return;
}
p->rowH = p->outH - (p->tileYI << dcPathFiller_tileSizeL2S);
if (p->rowH > dcPathFiller_tileSize)
p->rowH = dcPathFiller_tileSize;
p->rowHTiF = (f32)p->rowH / dcPathFiller_tileSizeF;
}
/* update left side effects */
{ Run r;
for (r = p->tileRuns[p->tileXI - 1][p->tileYI]; r != NULL; r = r->next) {
f32 rspy0 = r->rspy0;
f32 rspy1 = r->rspy1;
LeftSide ls, lslink, tmp;
/* no rightside projection? */
if (rspy1 == rspyImpossibleTss) {
continue;
}
/* constrain [rsp] to the interval [0,rowHTiF] */
if (rspy0 < 0.0F) rspy0 = 0.0F;
if (rspy1 < 0.0F) rspy1 = 0.0F;
if (rspy0 > p->rowHTiF) rspy0 = p->rowHTiF;
if (rspy1 > p->rowHTiF) rspy1 = p->rowHTiF;
/* for each [ls] in [lsEffects] check whether [rsp]
extends it; if so, modify [rsp] accordingly and remove
[ls] from [lsEffects] */
ls = p->lsEffects;
lslink = NULL;
while (ls != NULL) {
if (rspy1 == ls->y0 || rspy0 == ls->y1) {
if (rspy1 == ls->y0) rspy1 = ls->y1;
else rspy0 = ls->y0;
if (lslink == NULL)
p->lsEffects = ls->next;
else
lslink->next = ls->next;
tmp = ls->next;
ls->next = NULL;
LeftSide_releaseList(env, ls);
ls = tmp;
} else {
lslink = ls;
ls = ls->next;
}
}
/* if [rsp] still produces an effect, insert it in [lsEffect] */
if (rspy0 != rspy1) {
ls = LeftSide_create(env, p->poolLeftSide); if (ls == NULL) return;
ls->y0 = rspy0;
ls->y1 = rspy1;
ls->next = p->lsEffects;
p->lsEffects = ls;
}
}
}
}
static void
setOutputArea(doeE env, dcPathFiller pf, f32 outlox, f32 outloy, i32 w, i32 h)
{
dcPathFillerData* p = (dcPathFillerData*)pf;
dcFastPathProducer fpp = p->thisFPP;
i32 xi, yi;
/* check state, parameters */
if (!((dcPathStoreData*)p)->pathDefined) {
doeError_set(env, dcPRError, dcPRError_UNEX_setOutputArea);
return;
}
if (w <= 0 || h <= 0) {
doeError_set(env, dcPRError, dcPRError_BAD_outputarea);
return;
}
if (!( dcPathFiller_validLoCoord(outlox) &&
dcPathFiller_validLoCoord(outloy) &&
dcPathFiller_validHiCoord(outlox + w) &&
dcPathFiller_validHiCoord(outloy + h))) {
doeError_set(env, dcPRException, dcPRException_BAD_COORD_setOutputArea);
return;
}
stateSet(p, setOutputAreaDone);
p->outLoX = outlox;
p->outLoY = outloy;
p->outW = w;
p->outH = h;
p->outWTiF = w / dcPathFiller_tileSizeF;
p->outHTiF = h / dcPathFiller_tileSizeF;
if (p->tileRuns != NULL)
doeMem_free(env, p->tileRuns);
p->fastOutput = w <= dcPathFiller_tileSize &&
h <= dcPathFiller_tileSize &&
p->pathBox[0] >= outlox &&
p->pathBox[1] >= outloy &&
p->pathBox[2] <= outlox + w &&
p->pathBox[3] <= outloy + h;
if (p->fastOutput)
return;
/* allocate [tileRuns], indexed [xindex][yindex];
(here we reuse [w] and [h] as width and height in tiles) */
p->outWTi = w = (p->outW + dcPathFiller_tileSize - 1) >> dcPathFiller_tileSizeL2S;
p->outHTi = h = (p->outH + dcPathFiller_tileSize - 1) >> dcPathFiller_tileSizeL2S;
p->tileRuns = doeMem_malloc(env,
sizeof(Run*)*(w + 1) /* array of (Run*), indexed by X */
+ sizeof(Run )*(w + 1)*h/* arrays of (Run), indexed by Y */
);
if (p->tileRuns == NULL) {
doeError_setNoMemory(env);
return;
}
for (xi = 0; xi <= w; xi++) {
p->tileRuns[xi] = (Run*)(p->tileRuns + w + 1) + xi * h;
}
for (yi = 0; yi < h; yi++) {
for (xi = 0; xi <= w; xi++) {
p->tileRuns[xi][yi] = NULL;
}
}
(*fpp)->sendTo(env, fpp, p->runsBuilder);
if (doeError_occurred(env)) {
doeError_setNoMemory(env);
return;
}
/* set things so [nextTile] will advance to the 1st tile */
p->tileXI = w;
p->tileYI = -1;
(*pf)->nextTile(env, pf);
}
static void
PC_useProxy(doeE env, dcPathConsumer pc, dcFastPathProducer proxy)
{
doeError_set(env, dcPathError, dcPathError_UNEX_useProxy);
}
