static void
Transform_SafeHelper(JNIEnv *env,
SurfaceDataOps *srcOps,
SurfaceDataOps *dstOps,
SurfaceDataRasInfo *pSrcInfo,
SurfaceDataRasInfo *pDstInfo,
NativePrimitive *pMaskBlitPrim,
CompositeInfo *pCompInfo,
TransformHelperFunc *pHelperFunc,
TransformInterpFunc *pInterpFunc,
RegionData *pClipInfo, TransformInfo *pItxInfo,
jint *pData, jint *pEdges,
jint dxoff, jint dyoff, jint sw, jint sh)
{
SurfaceDataBounds span;
jint dx1, dx2;
jint dy1, dy2;
jint i, iy;
dy1 = pDstInfo->bounds.y1;
dy2 = pDstInfo->bounds.y2;
dx1 = pDstInfo->bounds.x1;
dx2 = pDstInfo->bounds.x2;
pEdges[0] = dy1;
pEdges[1] = dy2;
for (iy = dy1; iy < dy2; iy++) {
jint i = (iy - dy1) * 2;
/* row spans are set to max,min until we find a pixel in range below */
pEdges[i + 2] = dx2;
pEdges[i + 3] = dx1;
}
Region_StartIteration(env, pClipInfo);
while (Region_NextIteration(pClipInfo, &span)) {
dy1 = span.y1;
dy2 = span.y2;
while (dy1 < dy2) {
dx1 = span.x1;
dx2 = span.x2;
i = (dy1 - pDstInfo->bounds.y1) * 2;
while (dx1 < dx2) {
jdouble x, y;
jlong xlong, ylong;
x = dxoff + dx1 + 0.5;
y = dyoff + dy1 + 0.5;
Transform_transform(pItxInfo, &x, &y);
xlong = DblToLong(x);
ylong = DblToLong(y);
/* Process only pixels with centers in bounds
* Test double values to avoid overflow in conversion
* to long values and then also test the long values
* in case they rounded up and out of bounds during
* the conversion.
*/
if (x >= 0 && y >= 0 && x < sw && y < sh &&
WholeOfLong(xlong) < sw &&
WholeOfLong(ylong) < sh)
{
void *pDst;
if (pEdges[i + 2] > dx1) {
pEdges[i + 2] = dx1;
}
if (pEdges[i + 3] <= dx1) {
pEdges[i + 3] = dx1 + 1;
}
/* Get IntArgbPre pixel data from source */
(*pHelperFunc)(pSrcInfo,
pData, 1,
xlong, 0,
ylong, 0);
/* Interpolate result pixels if needed */
if (pInterpFunc) {
(*pInterpFunc)(pData, 1,
FractOfLong(xlong-LongOneHalf), 0,
FractOfLong(ylong-LongOneHalf), 0);
}
/* Store/Composite interpolated pixels into dest */
pDst = PtrCoord(pDstInfo->rasBase,
dx1, pDstInfo->pixelStride,
dy1, pDstInfo->scanStride);
(*pMaskBlitPrim->funcs.maskblit)(pDst, pData,
0, 0, 0,
1, 1,
pDstInfo, pSrcInfo,
pMaskBlitPrim,
pCompInfo);
}
/* Increment to next input pixel */
dx1++;
}
/* Increment to next scanline */
dy1++;
}
}
Region_EndIteration(env, pClipInfo);
}
/*
* Class: sun_java2d_loops_TransformHelper
* Method: Transform
* Signature: (Lsun/java2d/loops/MaskBlit;Lsun/java2d/SurfaceData;Lsun/java2d/SurfaceData;Ljava/awt/Composite;Lsun/java2d/pipe/Region;Ljava/awt/geom/AffineTransform;IIIIIIIII[I)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_TransformHelper_Transform
(JNIEnv *env, jobject self,
jobject maskblit,
jobject srcData, jobject dstData,
jobject comp, jobject clip,
jobject itxform, jint txtype,
jint sx1, jint sy1, jint sx2, jint sy2,
jint dx1, jint dy1, jint dx2, jint dy2,
jintArray edgeArray, jint dxoff, jint dyoff)
{
SurfaceDataOps *srcOps;
SurfaceDataOps *dstOps;
SurfaceDataRasInfo srcInfo;
SurfaceDataRasInfo dstInfo;
NativePrimitive *pHelperPrim;
NativePrimitive *pMaskBlitPrim;
CompositeInfo compInfo;
RegionData clipInfo;
TransformInfo itxInfo;
jint maxlinepix;
TransformHelperFunc *pHelperFunc;
TransformInterpFunc *pInterpFunc;
jdouble xorig, yorig;
jlong numedges;
jint *pEdges;
jint edgebuf[2 + MAXEDGES * 2];
union {
jlong align;
jint data[LINE_SIZE];
} rgb;
#ifdef MAKE_STUBS
static int th_initialized;
/* For debugging only - used to swap in alternate funcs for perf testing */
if (!th_initialized) {
if (getenv("TXSTUB") != 0) {
pBilinearFunc = BilinearInterpStub;
pBicubicFunc = BicubicInterpStub;
} else if (getenv("TXNOVIS") != 0) {
pBilinearFunc = BilinearInterp;
pBicubicFunc = BicubicInterp;
}
th_initialized = 1;
}
#endif /* MAKE_STUBS */
pHelperPrim = GetNativePrim(env, self);
if (pHelperPrim == NULL) {
/* Should never happen... */
return;
}
pMaskBlitPrim = GetNativePrim(env, maskblit);
if (pMaskBlitPrim == NULL) {
/* Exception was thrown by GetNativePrim */
return;
}
if (pMaskBlitPrim->pCompType->getCompInfo != NULL) {
(*pMaskBlitPrim->pCompType->getCompInfo)(env, &compInfo, comp);
}
if (Region_GetInfo(env, clip, &clipInfo)) {
return;
}
srcOps = SurfaceData_GetOps(env, srcData);
dstOps = SurfaceData_GetOps(env, dstData);
if (srcOps == 0 || dstOps == 0) {
return;
}
/*
* Grab the appropriate pointer to the helper and interpolation
* routines and calculate the maximum number of destination pixels
* that can be processed in one intermediate buffer based on the
* size of the buffer and the number of samples needed per pixel.
*/
switch (txtype) {
case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR:
pHelperFunc = pHelperPrim->funcs.transformhelpers->nnHelper;
pInterpFunc = NULL;
maxlinepix = LINE_SIZE;
break;
case java_awt_image_AffineTransformOp_TYPE_BILINEAR:
pHelperFunc = pHelperPrim->funcs.transformhelpers->blHelper;
pInterpFunc = pBilinearFunc;
maxlinepix = LINE_SIZE / 4;
break;
case java_awt_image_AffineTransformOp_TYPE_BICUBIC:
pHelperFunc = pHelperPrim->funcs.transformhelpers->bcHelper;
pInterpFunc = pBicubicFunc;
maxlinepix = LINE_SIZE / 16;
break;
}
srcInfo.bounds.x1 = sx1;
srcInfo.bounds.y1 = sy1;
srcInfo.bounds.x2 = sx2;
srcInfo.bounds.y2 = sy2;
dstInfo.bounds.x1 = dx1;
dstInfo.bounds.y1 = dy1;
dstInfo.bounds.x2 = dx2;
dstInfo.bounds.y2 = dy2;
SurfaceData_IntersectBounds(&dstInfo.bounds, &clipInfo.bounds);
if (srcOps->Lock(env, srcOps, &srcInfo, pHelperPrim->srcflags)
!= SD_SUCCESS)
{
/* edgeArray should already contain zeros for min/maxy */
return;
}
if (dstOps->Lock(env, dstOps, &dstInfo, pMaskBlitPrim->dstflags)
!= SD_SUCCESS)
{
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
/* edgeArray should already contain zeros for min/maxy */
return;
}
Region_IntersectBounds(&clipInfo, &dstInfo.bounds);
numedges = (((jlong) dstInfo.bounds.y2) - ((jlong) dstInfo.bounds.y1));
if (numedges <= 0) {
pEdges = NULL;
} else if (!JNU_IsNull(env, edgeArray)) {
/*
* Ideally Java should allocate an array large enough, but if
* we ever have a miscommunication about the number of edge
* lines, or if the Java array calculation should overflow to
* a positive number and succeed in allocating an array that
* is too small, we need to verify that it can still hold the
* number of integers that we plan to store to be safe.
*/
jsize edgesize = (*env)->GetArrayLength(env, edgeArray);
/* (edgesize/2 - 1) should avoid any overflow or underflow. */
pEdges = (((edgesize / 2) - 1) >= numedges)
? (*env)->GetPrimitiveArrayCritical(env, edgeArray, NULL)
: NULL;
} else if (numedges > MAXEDGES) {
/* numedges variable (jlong) can be at most ((1<<32)-1) */
/* memsize can overflow a jint, but not a jlong */
jlong memsize = ((numedges * 2) + 2) * sizeof(*pEdges);
pEdges = (memsize == ((size_t) memsize))
? malloc((size_t) memsize)
: NULL;
} else {
pEdges = edgebuf;
}
if (pEdges == NULL) {
if (numedges > 0) {
JNU_ThrowInternalError(env, "Unable to allocate edge list");
}
SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
/* edgeArray should already contain zeros for min/maxy */
return;
}
Transform_GetInfo(env, itxform, &itxInfo);
if (!Region_IsEmpty(&clipInfo)) {
srcOps->GetRasInfo(env, srcOps, &srcInfo);
dstOps->GetRasInfo(env, dstOps, &dstInfo);
if (srcInfo.rasBase == NULL || dstInfo.rasBase == NULL) {
pEdges[0] = pEdges[1] = 0;
} else if (checkOverflow(dxoff, dyoff, &dstInfo.bounds,
&itxInfo, &xorig, &yorig))
{
Transform_SafeHelper(env, srcOps, dstOps,
&srcInfo, &dstInfo,
pMaskBlitPrim, &compInfo,
pHelperFunc, pInterpFunc,
&clipInfo, &itxInfo, rgb.data, pEdges,
dxoff, dyoff, sx2-sx1, sy2-sy1);
} else {
SurfaceDataBounds span;
jlong dxdxlong, dydxlong;
jlong dxdylong, dydylong;
jlong xbase, ybase;
dxdxlong = DblToLong(itxInfo.dxdx);
dydxlong = DblToLong(itxInfo.dydx);
dxdylong = DblToLong(itxInfo.dxdy);
dydylong = DblToLong(itxInfo.dydy);
xbase = DblToLong(xorig);
ybase = DblToLong(yorig);
calculateEdges(pEdges, &dstInfo.bounds, &itxInfo,
xbase, ybase, sx2-sx1, sy2-sy1);
Region_StartIteration(env, &clipInfo);
while (Region_NextIteration(&clipInfo, &span)) {
jlong rowxlong, rowylong;
void *pDst;
dy1 = span.y1;
dy2 = span.y2;
rowxlong = xbase + (dy1 - dstInfo.bounds.y1) * dxdylong;
rowylong = ybase + (dy1 - dstInfo.bounds.y1) * dydylong;
while (dy1 < dy2) {
jlong xlong, ylong;
/* Note - process at most one scanline at a time. */
dx1 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 2];
dx2 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 3];
if (dx1 < span.x1) dx1 = span.x1;
if (dx2 > span.x2) dx2 = span.x2;
/* All pixels from dx1 to dx2 have centers in bounds */
while (dx1 < dx2) {
/* Can process at most one buffer full at a time */
jint numpix = dx2 - dx1;
if (numpix > maxlinepix) {
numpix = maxlinepix;
}
xlong =
rowxlong + ((dx1 - dstInfo.bounds.x1) * dxdxlong);
ylong =
rowylong + ((dx1 - dstInfo.bounds.x1) * dydxlong);
/* Get IntArgbPre pixel data from source */
(*pHelperFunc)(&srcInfo,
rgb.data, numpix,
xlong, dxdxlong,
ylong, dydxlong);
/* Interpolate result pixels if needed */
if (pInterpFunc) {
(*pInterpFunc)(rgb.data, numpix,
FractOfLong(xlong-LongOneHalf),
FractOfLong(dxdxlong),
FractOfLong(ylong-LongOneHalf),
FractOfLong(dydxlong));
}
/* Store/Composite interpolated pixels into dest */
pDst = PtrCoord(dstInfo.rasBase,
dx1, dstInfo.pixelStride,
dy1, dstInfo.scanStride);
(*pMaskBlitPrim->funcs.maskblit)(pDst, rgb.data,
0, 0, 0,
numpix, 1,
&dstInfo, &srcInfo,
pMaskBlitPrim,
&compInfo);
/* Increment to next buffer worth of input pixels */
dx1 += maxlinepix;
}
/* Increment to next scanline */
rowxlong += dxdylong;
rowylong += dydylong;
dy1++;
}
}
Region_EndIteration(env, &clipInfo);
}
SurfaceData_InvokeRelease(env, dstOps, &dstInfo);
SurfaceData_InvokeRelease(env, srcOps, &srcInfo);
} else {
pEdges[0] = pEdges[1] = 0;
}
if (!JNU_IsNull(env, edgeArray)) {
(*env)->ReleasePrimitiveArrayCritical(env, edgeArray, pEdges, 0);
} else if (pEdges != edgebuf) {
free(pEdges);
}
SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
}
/*
* Fill the edge buffer with pairs of coordinates representing the maximum
* left and right pixels of the destination surface that should be processed
* on each scanline, clipped to the bounds parameter.
* The number of scanlines to calculate is implied by the bounds parameter.
* Only pixels that map back through the specified (inverse) transform to a
* source coordinate that falls within the (0, 0, sw, sh) bounds of the
* source image should be processed.
* pEdgeBuf points to an array of jints that holds MAXEDGES*2 values.
* If more storage is needed, then this function allocates a new buffer.
* In either case, a pointer to the buffer actually used to store the
* results is returned.
* The caller is responsible for freeing the buffer if the return value
* is not the same as the original pEdgeBuf passed in.
*/
static jint *
calculateEdges(jint *pEdgeBuf,
SurfaceDataBounds *pBounds,
TransformInfo *pItxInfo,
jlong xbase, jlong ybase,
juint sw, juint sh)
{
jint *pEdges;
jlong dxdxlong, dydxlong;
jlong dxdylong, dydylong;
jlong drowxlong, drowylong;
jint dx1, dy1, dx2, dy2;
dxdxlong = DblToLong(pItxInfo->dxdx);
dydxlong = DblToLong(pItxInfo->dydx);
dxdylong = DblToLong(pItxInfo->dxdy);
dydylong = DblToLong(pItxInfo->dydy);
dx1 = pBounds->x1;
dy1 = pBounds->y1;
dx2 = pBounds->x2;
dy2 = pBounds->y2;
if ((dy2-dy1) > MAXEDGES) {
pEdgeBuf = malloc(2 * (dy2-dy1) * sizeof (*pEdges));
}
pEdges = pEdgeBuf;
drowxlong = (dx2-dx1-1) * dxdxlong;
drowylong = (dx2-dx1-1) * dydxlong;
while (dy1 < dy2) {
jlong xlong, ylong;
dx1 = pBounds->x1;
dx2 = pBounds->x2;
xlong = xbase;
ylong = ybase;
while (dx1 < dx2 &&
(((juint) WholeOfLong(ylong)) >= sh ||
((juint) WholeOfLong(xlong)) >= sw))
{
dx1++;
xlong += dxdxlong;
ylong += dydxlong;
}
xlong = xbase + drowxlong;
ylong = ybase + drowylong;
while (dx2 > dx1 &&
(((juint) WholeOfLong(ylong)) >= sh ||
((juint) WholeOfLong(xlong)) >= sw))
{
dx2--;
xlong -= dxdxlong;
ylong -= dydxlong;
}
*pEdges++ = dx1;
*pEdges++ = dx2;
/* Increment to next scanline */
xbase += dxdylong;
ybase += dydylong;
dy1++;
}
return pEdgeBuf;
}
/*
* Fill the edge buffer with pairs of coordinates representing the maximum
* left and right pixels of the destination surface that should be processed
* on each scanline, clipped to the bounds parameter.
* The number of scanlines to calculate is implied by the bounds parameter.
* Only pixels that map back through the specified (inverse) transform to a
* source coordinate that falls within the (0, 0, sw, sh) bounds of the
* source image should be processed.
* pEdges points to an array of jints that holds 2 + numedges*2 values where
* numedges should match (pBounds->y2 - pBounds->y1).
* The first two jints in pEdges should be set to y1 and y2 and every pair
* of jints after that represent the xmin,xmax of all pixels in range of
* the transformed blit for the corresponding scanline.
*/
static void
calculateEdges(jint *pEdges,
SurfaceDataBounds *pBounds,
TransformInfo *pItxInfo,
jlong xbase, jlong ybase,
juint sw, juint sh)
{
jlong dxdxlong, dydxlong;
jlong dxdylong, dydylong;
jlong drowxlong, drowylong;
jint dx1, dy1, dx2, dy2;
dxdxlong = DblToLong(pItxInfo->dxdx);
dydxlong = DblToLong(pItxInfo->dydx);
dxdylong = DblToLong(pItxInfo->dxdy);
dydylong = DblToLong(pItxInfo->dydy);
dx1 = pBounds->x1;
dy1 = pBounds->y1;
dx2 = pBounds->x2;
dy2 = pBounds->y2;
*pEdges++ = dy1;
*pEdges++ = dy2;
drowxlong = (dx2-dx1-1) * dxdxlong;
drowylong = (dx2-dx1-1) * dydxlong;
while (dy1 < dy2) {
jlong xlong, ylong;
dx1 = pBounds->x1;
dx2 = pBounds->x2;
xlong = xbase;
ylong = ybase;
while (dx1 < dx2 &&
(((juint) WholeOfLong(ylong)) >= sh ||
((juint) WholeOfLong(xlong)) >= sw))
{
dx1++;
xlong += dxdxlong;
ylong += dydxlong;
}
xlong = xbase + drowxlong;
ylong = ybase + drowylong;
while (dx2 > dx1 &&
(((juint) WholeOfLong(ylong)) >= sh ||
((juint) WholeOfLong(xlong)) >= sw))
{
dx2--;
xlong -= dxdxlong;
ylong -= dydxlong;
}
*pEdges++ = dx1;
*pEdges++ = dx2;
/* Increment to next scanline */
xbase += dxdylong;
ybase += dydylong;
dy1++;
}
}
/*
* Class: sun_java2d_loops_TransformHelper
* Method: Transform
* Signature: (Lsun/java2d/loops/MaskBlit;Lsun/java2d/SurfaceData;Lsun/java2d/SurfaceData;Ljava/awt/Composite;Lsun/java2d/pipe/Region;Ljava/awt/geom/AffineTransform;IIIIIIIII[I)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_TransformHelper_Transform
(JNIEnv *env, jobject self,
jobject maskblit,
jobject srcData, jobject dstData,
jobject comp, jobject clip,
jobject itxform, jint txtype,
jint sx1, jint sy1, jint sx2, jint sy2,
jint dx1, jint dy1, jint dx2, jint dy2,
jintArray edgeArray, jint dxoff, jint dyoff)
{
SurfaceDataOps *srcOps;
SurfaceDataOps *dstOps;
SurfaceDataRasInfo srcInfo;
SurfaceDataRasInfo dstInfo;
NativePrimitive *pHelperPrim;
NativePrimitive *pMaskBlitPrim;
CompositeInfo compInfo;
RegionData clipInfo;
TransformInfo itxInfo;
jint maxlinepix;
TransformHelperFunc *pHelperFunc;
TransformInterpFunc *pInterpFunc;
jint edgebuf[MAXEDGES * 2];
jint *pEdges;
jdouble x, y;
jlong xbase, ybase;
jlong dxdxlong, dydxlong;
jlong dxdylong, dydylong;
#ifdef MAKE_STUBS
static int th_initialized;
/* For debugging only - used to swap in alternate funcs for perf testing */
if (!th_initialized) {
if (getenv("TXSTUB") != 0) {
pBilinearFunc = BilinearInterpStub;
pBicubicFunc = BicubicInterpStub;
} else if (getenv("TXNOVIS") != 0) {
pBilinearFunc = BilinearInterp;
pBicubicFunc = BicubicInterp;
}
th_initialized = 1;
}
#endif /* MAKE_STUBS */
pHelperPrim = GetNativePrim(env, self);
if (pHelperPrim == NULL) {
/* Should never happen... */
return;
}
pMaskBlitPrim = GetNativePrim(env, maskblit);
if (pMaskBlitPrim == NULL) {
/* Exception was thrown by GetNativePrim */
return;
}
if (pMaskBlitPrim->pCompType->getCompInfo != NULL) {
(*pMaskBlitPrim->pCompType->getCompInfo)(env, &compInfo, comp);
}
if (Region_GetInfo(env, clip, &clipInfo)) {
return;
}
srcOps = SurfaceData_GetOps(env, srcData);
dstOps = SurfaceData_GetOps(env, dstData);
if (srcOps == 0 || dstOps == 0) {
return;
}
/*
* Grab the appropriate pointer to the helper and interpolation
* routines and calculate the maximum number of destination pixels
* that can be processed in one intermediate buffer based on the
* size of the buffer and the number of samples needed per pixel.
*/
switch (txtype) {
case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR:
pHelperFunc = pHelperPrim->funcs.transformhelpers->nnHelper;
pInterpFunc = NULL;
maxlinepix = LINE_SIZE;
break;
case java_awt_image_AffineTransformOp_TYPE_BILINEAR:
pHelperFunc = pHelperPrim->funcs.transformhelpers->blHelper;
pInterpFunc = pBilinearFunc;
maxlinepix = LINE_SIZE / 4;
break;
case java_awt_image_AffineTransformOp_TYPE_BICUBIC:
pHelperFunc = pHelperPrim->funcs.transformhelpers->bcHelper;
pInterpFunc = pBicubicFunc;
maxlinepix = LINE_SIZE / 16;
break;
}
srcInfo.bounds.x1 = sx1;
srcInfo.bounds.y1 = sy1;
srcInfo.bounds.x2 = sx2;
srcInfo.bounds.y2 = sy2;
dstInfo.bounds.x1 = dx1;
dstInfo.bounds.y1 = dy1;
dstInfo.bounds.x2 = dx2;
dstInfo.bounds.y2 = dy2;
SurfaceData_IntersectBounds(&dstInfo.bounds, &clipInfo.bounds);
if (srcOps->Lock(env, srcOps, &srcInfo, pHelperPrim->srcflags)
!= SD_SUCCESS)
{
return;
}
if (dstOps->Lock(env, dstOps, &dstInfo, pMaskBlitPrim->dstflags)
!= SD_SUCCESS)
{
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
return;
}
Region_IntersectBounds(&clipInfo, &dstInfo.bounds);
Transform_GetInfo(env, itxform, &itxInfo);
dxdxlong = DblToLong(itxInfo.dxdx);
dydxlong = DblToLong(itxInfo.dydx);
dxdylong = DblToLong(itxInfo.dxdy);
dydylong = DblToLong(itxInfo.dydy);
x = dxoff+dstInfo.bounds.x1+0.5; /* Center of pixel x1 */
y = dyoff+dstInfo.bounds.y1+0.5; /* Center of pixel y1 */
Transform_transform(&itxInfo, &x, &y);
xbase = DblToLong(x);
ybase = DblToLong(y);
pEdges = calculateEdges(edgebuf, &dstInfo.bounds, &itxInfo,
xbase, ybase, sx2-sx1, sy2-sy1);
if (!Region_IsEmpty(&clipInfo)) {
srcOps->GetRasInfo(env, srcOps, &srcInfo);
dstOps->GetRasInfo(env, dstOps, &dstInfo);
if (srcInfo.rasBase && dstInfo.rasBase) {
union {
jlong align;
jint data[LINE_SIZE];
} rgb;
SurfaceDataBounds span;
Region_StartIteration(env, &clipInfo);
while (Region_NextIteration(&clipInfo, &span)) {
jlong rowxlong, rowylong;
void *pDst;
dy1 = span.y1;
dy2 = span.y2;
rowxlong = xbase + (dy1 - dstInfo.bounds.y1) * dxdylong;
rowylong = ybase + (dy1 - dstInfo.bounds.y1) * dydylong;
while (dy1 < dy2) {
jlong xlong, ylong;
/* Note - process at most one scanline at a time. */
dx1 = pEdges[(dy1 - dstInfo.bounds.y1) * 2];
dx2 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 1];
if (dx1 < span.x1) dx1 = span.x1;
if (dx2 > span.x2) dx2 = span.x2;
/* All pixels from dx1 to dx2 have centers in bounds */
while (dx1 < dx2) {
/* Can process at most one buffer full at a time */
jint numpix = dx2 - dx1;
if (numpix > maxlinepix) {
numpix = maxlinepix;
}
xlong =
rowxlong + ((dx1 - dstInfo.bounds.x1) * dxdxlong);
ylong =
rowylong + ((dx1 - dstInfo.bounds.x1) * dydxlong);
/* Get IntArgbPre pixel data from source */
(*pHelperFunc)(&srcInfo,
rgb.data, numpix,
xlong, dxdxlong,
ylong, dydxlong);
/* Interpolate result pixels if needed */
if (pInterpFunc) {
(*pInterpFunc)(rgb.data, numpix,
FractOfLong(xlong-LongOneHalf),
FractOfLong(dxdxlong),
FractOfLong(ylong-LongOneHalf),
FractOfLong(dydxlong));
}
/* Store/Composite interpolated pixels into dest */
pDst = PtrCoord(dstInfo.rasBase,
dx1, dstInfo.pixelStride,
dy1, dstInfo.scanStride);
(*pMaskBlitPrim->funcs.maskblit)(pDst, rgb.data,
0, 0, 0,
numpix, 1,
&dstInfo, &srcInfo,
pMaskBlitPrim,
&compInfo);
/* Increment to next buffer worth of input pixels */
dx1 += maxlinepix;
}
/* Increment to next scanline */
rowxlong += dxdylong;
rowylong += dydylong;
dy1++;
}
}
Region_EndIteration(env, &clipInfo);
}
SurfaceData_InvokeRelease(env, dstOps, &dstInfo);
SurfaceData_InvokeRelease(env, srcOps, &srcInfo);
}
SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
if (!JNU_IsNull(env, edgeArray)) {
(*env)->SetIntArrayRegion(env, edgeArray, 0, 1, &dstInfo.bounds.y1);
(*env)->SetIntArrayRegion(env, edgeArray, 1, 1, &dstInfo.bounds.y2);
(*env)->SetIntArrayRegion(env, edgeArray,
2, (dstInfo.bounds.y2 - dstInfo.bounds.y1)*2,
pEdges);
}
if (pEdges != edgebuf) {
free(pEdges);
}
}
