/*
* Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include <jlong.h>
#include "D3DBufImgOps.h"
#include "D3DContext.h"
#include "D3DRenderQueue.h"
#include "D3DSurfaceData.h"
#include "GraphicsPrimitiveMgr.h"
/**************************** ConvolveOp support ****************************/
/**
* The maximum kernel size supported by the ConvolveOp shader.
*/
#define MAX_KERNEL_SIZE 25
HRESULT
D3DBufImgOps_EnableConvolveOp(D3DContext *d3dc, jlong pSrcOps,
jboolean edgeZeroFill,
jint kernelWidth, jint kernelHeight,
unsigned char *kernel)
{
HRESULT res;
IDirect3DDevice9 *pd3dDevice;
D3DSDOps *srcOps = (D3DSDOps *)jlong_to_ptr(pSrcOps);
jint kernelSize = kernelWidth * kernelHeight;
jint texW, texH;
jfloat xoff, yoff;
jfloat edgeX, edgeY;
jfloat imgEdge[4];
jfloat kernelVals[MAX_KERNEL_SIZE*4];
jint i, j, kIndex;
jint flags = 0;
J2dTraceLn2(J2D_TRACE_INFO,
"D3DBufImgOps_EnableConvolveOp: kernelW=%d kernelH=%d",
kernelWidth, kernelHeight);
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
RETURN_STATUS_IF_NULL(srcOps, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// texcoords are specified in the range [0,1], so to achieve an
// x/y offset of approximately one pixel we have to normalize
// to that range here
texW = srcOps->pResource->GetDesc()->Width;
texH = srcOps->pResource->GetDesc()->Height;
xoff = 1.0f / texW;
yoff = 1.0f / texH;
if (edgeZeroFill) {
flags |= CONVOLVE_EDGE_ZERO_FILL;
}
if (kernelWidth == 5 && kernelHeight == 5) {
flags |= CONVOLVE_5X5;
}
// locate/enable the shader program for the given flags
res = d3dc->EnableConvolveProgram(flags);
RETURN_STATUS_IF_FAILED(res);
// update the "uniform" image min/max values
// (texcoords are in the range [0,1])
// imgEdge[0] = imgMin.x
// imgEdge[1] = imgMin.y
// imgEdge[2] = imgMax.x
// imgEdge[3] = imgMax.y
edgeX = (kernelWidth/2) * xoff;
edgeY = (kernelHeight/2) * yoff;
imgEdge[0] = edgeX;
imgEdge[1] = edgeY;
imgEdge[2] = (((jfloat)srcOps->width) / texW) - edgeX;
imgEdge[3] = (((jfloat)srcOps->height) / texH) - edgeY;
pd3dDevice = d3dc->Get3DDevice();
pd3dDevice->SetPixelShaderConstantF(0, imgEdge, 1);
// update the "uniform" kernel offsets and values
kIndex = 0;
for (i = -kernelHeight/2; i < kernelHeight/2+1; i++) {
for (j = -kernelWidth/2; j < kernelWidth/2+1; j++) {
kernelVals[kIndex+0] = j*xoff;
kernelVals[kIndex+1] = i*yoff;
kernelVals[kIndex+2] = NEXT_FLOAT(kernel);
kernelVals[kIndex+3] = 0.0f; // unused
kIndex += 4;
}
}
return pd3dDevice->SetPixelShaderConstantF(1, kernelVals, kernelSize);
}
HRESULT
D3DBufImgOps_DisableConvolveOp(D3DContext *d3dc)
{
IDirect3DDevice9 *pd3dDevice;
J2dTraceLn(J2D_TRACE_INFO, "D3DBufImgOps_DisableConvolveOp");
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// disable the ConvolveOp shader
pd3dDevice = d3dc->Get3DDevice();
return pd3dDevice->SetPixelShader(NULL);
}
/**************************** RescaleOp support *****************************/
HRESULT
D3DBufImgOps_EnableRescaleOp(D3DContext *d3dc,
jboolean nonPremult,
unsigned char *scaleFactors,
unsigned char *offsets)
{
HRESULT res;
IDirect3DDevice9 *pd3dDevice;
jint flags = 0;
J2dTraceLn(J2D_TRACE_INFO, "D3DBufImgOps_EnableRescaleOp");
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// choose the appropriate shader, depending on the source image
if (nonPremult) {
flags |= RESCALE_NON_PREMULT;
}
// locate/enable the shader program for the given flags
res = d3dc->EnableRescaleProgram(flags);
RETURN_STATUS_IF_FAILED(res);
// update the "uniform" scale factor values (note that the Java-level
// dispatching code always passes down 4 values here, regardless of
// the original source image type)
pd3dDevice = d3dc->Get3DDevice();
pd3dDevice->SetPixelShaderConstantF(0, (float *)scaleFactors, 1);
// update the "uniform" offset values (note that the Java-level
// dispatching code always passes down 4 values here, and that the
// offsets will have already been normalized to the range [0,1])
return pd3dDevice->SetPixelShaderConstantF(1, (float *)offsets, 1);
}
HRESULT
D3DBufImgOps_DisableRescaleOp(D3DContext *d3dc)
{
IDirect3DDevice9 *pd3dDevice;
J2dTraceLn(J2D_TRACE_INFO, "D3DBufImgOps_DisableRescaleOp");
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// disable the RescaleOp shader
pd3dDevice = d3dc->Get3DDevice();
return pd3dDevice->SetPixelShader(NULL);
}
/**************************** LookupOp support ******************************/
HRESULT
D3DBufImgOps_EnableLookupOp(D3DContext *d3dc,
jboolean nonPremult, jboolean shortData,
jint numBands, jint bandLength, jint offset,
void *tableValues)
{
HRESULT res;
IDirect3DDevice9 *pd3dDevice;
D3DResource *pLutTexRes;
IDirect3DTexture9 *pLutTex;
int bytesPerElem = (shortData ? 2 : 1);
jfloat foffsets[4];
void *bands[4];
int i;
jint flags = 0;
J2dTraceLn4(J2D_TRACE_INFO,
"D3DBufImgOps_EnableLookupOp: short=%d num=%d len=%d off=%d",
shortData, numBands, bandLength, offset);
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// choose the appropriate shader, depending on the source image
// and the number of bands involved
if (numBands != 4) {
flags |= LOOKUP_USE_SRC_ALPHA;
}
if (nonPremult) {
flags |= LOOKUP_NON_PREMULT;
}
// locate/enable the shader program for the given flags
res = d3dc->EnableLookupProgram(flags);
RETURN_STATUS_IF_FAILED(res);
// update the "uniform" offset value
for (i = 0; i < 4; i++) {
foffsets[i] = offset / 255.0f;
}
pd3dDevice = d3dc->Get3DDevice();
pd3dDevice->SetPixelShaderConstantF(0, foffsets, 1);
res = d3dc->GetResourceManager()->GetLookupOpLutTexture(&pLutTexRes);
RETURN_STATUS_IF_FAILED(res);
pLutTex = pLutTexRes->GetTexture();
// update the lookup table with the user-provided values
if (numBands == 1) {
// replicate the single band for R/G/B; alpha band is unused
for (i = 0; i < 3; i++) {
bands[i] = tableValues;
}
bands[3] = NULL;
} else if (numBands == 3) {
// user supplied band for each of R/G/B; alpha band is unused
for (i = 0; i < 3; i++) {
bands[i] = PtrAddBytes(tableValues, i*bandLength*bytesPerElem);
}
bands[3] = NULL;
} else if (numBands == 4) {
// user supplied band for each of R/G/B/A
for (i = 0; i < 4; i++) {
bands[i] = PtrAddBytes(tableValues, i*bandLength*bytesPerElem);
}
}
// upload the bands one row at a time into our lookup table texture
D3DLOCKED_RECT lockedRect;
res = pLutTex->LockRect(0, &lockedRect, NULL, D3DLOCK_NOSYSLOCK);
RETURN_STATUS_IF_FAILED(res);
jushort *pBase = (jushort*)lockedRect.pBits;
for (i = 0; i < 4; i++) {
jushort *pDst;
if (bands[i] == NULL) {
continue;
}
pDst = pBase + (i * 256);
if (shortData) {
memcpy(pDst, bands[i], bandLength*sizeof(jushort));
} else {
int j;
jubyte *pSrc = (jubyte *)bands[i];
for (j = 0; j < bandLength; j++) {
pDst[j] = (jushort)(pSrc[j] << 8);
}
}
}
pLutTex->UnlockRect(0);
// bind the lookup table to texture unit 1 and enable texturing
res = d3dc->SetTexture(pLutTex, 1);
pd3dDevice->SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
pd3dDevice->SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
pd3dDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
return res;
}
HRESULT
D3DBufImgOps_DisableLookupOp(D3DContext *d3dc)
{
IDirect3DDevice9 *pd3dDevice;
J2dTraceLn(J2D_TRACE_INFO, "D3DBufImgOps_DisableLookupOp");
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// disable the LookupOp shader
pd3dDevice = d3dc->Get3DDevice();
pd3dDevice->SetPixelShader(NULL);
// disable the lookup table on texture unit 1
return d3dc->SetTexture(NULL, 1);
}