/*
* Copyright 2005-2006 Sun Microsystems, Inc. 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. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
#include "dxInit.h"
#include "ddrawUtils.h"
#include "RegistryKey.h"
#include "D3DTestRaster.h"
#include "WindowsFlags.h"
#include "D3DRuntimeTest.h"
#include "D3DSurfaceData.h"
#include "D3DUtils.h"
#ifdef DEBUG
void TestRasterOutput(byte *rasPtr, int x, int y, int w, int h,
int scanStride, int pixelStride,
TIntTestRaster goldenArray = NULL);
#endif // DEBUG
void PrintD3DCaps(int caps);
/**
* Test whether we should enable d3d rendering on this device.
* This includes checking whether there were problems creating
* the necessary offscreen surface, problems during any of the
* rendering calls (Blts and d3d lines) and any rendering artifacts
* caused by d3d lines. The rendering artifact tests are
* performed by checking a pre-rendered test pattern (produced
* by our software renderer) against that same pattern rendered
* on this device. If there are any pixels which differ between
* the two patterns we disable d3d line rendering on the device.
* Differences in the test pattern rendering can be caused
* by different rendering algorithms used by our software
* renderer and the driver or hardware on this device. For example,
* some Intel cards (e.g., i815) are known to use polygon renderers
* for their lines, which sometimes result in wide lines.
* The test pattern is stored in d3dTestRaster.h, which is generated
* by a Java test program
* (src/share/test/java2d/VolatileImage/D3DTestPattern/D3DTestPattern.java).
*/
int TestForBadHardware(DxCapabilities *dxCaps)
{
// Check this device against a list of bad d3d devices and
// disable as necessary
static WCHAR *badDeviceStrings[] = {
L"Trident Video Accelerator",
L"RAGE PRO",
L"RAGE XL",
L"Rage Fury",
};
static int numBadDevices = 4;
WCHAR *dxDeviceName = dxCaps->GetDeviceName();
for (int i = 0; i < numBadDevices; ++i) {
if (wcsstr(dxDeviceName, badDeviceStrings[i]) != NULL) {
// REMIND: For now, we disable d3d for all operations because
// of one bad d3d device in the system. This is because we
// should avoid registering the d3d rendering loops at the
// Java level since we cannot use d3d at the native level.
// A real fix would instead understand the difference between
// a surface that could handle d3d native rendering and one
// that could not and would use the appropriate rendering loop
// so that disabling d3d on simply one device would be
// sufficient.
// Note that this disable-all approach is okay for now because
// the single bad device (Trident) that triggers this error
// is generally found on laptops, where multiple graphics
// devices are not even possible, so disabling d3d for all
// devices is equivalent to disabling d3d for this single
// device.
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"TestForBadHardware: Found match: %S. Test FAILED",
badDeviceStrings[i]);
return J2D_D3D_FAILURE;
}
}
return J2D_D3D_HW_OK;
}
int TestTextureFormats(D3DContext *d3dContext)
{
int testRes = J2D_D3D_FAILURE;
D3DTextureTable &table = d3dContext->GetTextureTable();
int pfExists;
// Check that there's at least one valid pixel format
// for each transparency type (opaque, bitmask, translucent)
for (int t = TR_OPAQUE_IDX; t < TR_MAX_IDX; t++) {
pfExists = FALSE;
for (int d = DEPTH16_IDX; d < DEPTH_MAX_IDX; d++) {
if (table[t][d].pfType != PF_INVALID) {
pfExists = TRUE;
break;
}
}
if (pfExists == FALSE) {
// couldn't find a pixel formap for this transparency type
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"D3DTest::TestTextureFormats no texture formats"\
" for %d transparency", t);
break;
}
}
// we must have ARGB texture format (may be used for text rendering)
if (pfExists == TRUE &&
table[TR_TRANSLUCENT_IDX][DEPTH32_IDX].pfType == PF_INT_ARGB)
{
testRes |= J2D_D3D_PIXEL_FORMATS_OK;
} else {
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"D3DTest::TestTextureFormats: FAILED pfType=%d",
table[TR_TRANSLUCENT_IDX][DEPTH32_IDX].pfType);
}
return testRes;
}
int TestSetClip(JNIEnv *env, D3DContext *d3dContext,
DDrawSurface *lpPlainSurface)
{
int testRes = J2D_D3D_FAILURE;
if (SUCCEEDED(d3dContext->SetRenderTarget(lpPlainSurface))) {
jobject clip =
JNU_CallStaticMethodByName(env, NULL,
"sun/java2d/pipe/Region",
"getInstanceXYWH",
"(IIII)Lsun/java2d/pipe/Region;",
0, 0, D3D_TEST_RASTER_W, D3D_TEST_RASTER_H).l;
if (!JNU_IsNull(env, clip)) {
if (SUCCEEDED(d3dContext->SetClip(env, clip, JNI_TRUE,
0, 0,
D3D_TEST_RASTER_W,
D3D_TEST_RASTER_H)))
{
testRes |= J2D_D3D_DEPTH_SURFACE_OK;
}
env->DeleteLocalRef(clip);
}
}
return testRes;
}
int TestRenderingResults(DDrawSurface *lpPlainSurface,
TIntTestRaster goldenArray)
{
// Now, check the results of the test raster against our d3d drawing
SurfaceDataRasInfo rasInfo;
if (FAILED(lpPlainSurface->Lock(NULL, &rasInfo, DDLOCK_WAIT, NULL))) {
return J2D_D3D_FAILURE;
}
byte *rasPtr = (byte*)rasInfo.rasBase;
int pixelStride = rasInfo.pixelStride;
int scanStride = rasInfo.scanStride;
for (int row = 0; row < D3D_TEST_RASTER_H; ++row) {
byte *tmpRasPtr = rasPtr + row * scanStride;
for (int col = 0; col < D3D_TEST_RASTER_W; ++col) {
DWORD pixelVal;
switch (pixelStride) {
case 1:
pixelVal = *tmpRasPtr;
break;
case 2:
pixelVal = *((unsigned short*)tmpRasPtr);
break;
default:
pixelVal = *((unsigned int*)tmpRasPtr);
break;
}
tmpRasPtr += pixelStride;
// The test is simple: if the test raster pixel has value 0, then
// we expect 0 in the d3d surface. If the test raster has a nonzero
// value, then we expect the d3d surface to also have non-zero value.
// All other results represent failure.
int goldenValue = (goldenArray[row][col] & 0x00ffffff);
if ((goldenValue == 0 && pixelVal != 0) ||
(goldenValue != 0 && pixelVal == 0))
{
J2dRlsTraceLn3(J2D_TRACE_WARNING,
"TestRenderingResults: Quality test failed due "\
"to value %x at (%d, %d)", pixelVal, col, row);
#ifdef DEBUG
// This section is not necessary, but it might be
// nice to know why we are failing D3DTest on some
// systems. If tracing is enabled, this section will
// produce an ascii representation of the test pattern,
// the result on this device, and the pixels that were
// in error.
J2dTraceLn(J2D_TRACE_VERBOSE, "TestRaster:");
TestRasterOutput((byte*)goldenArray, 0, 0, D3D_TEST_RASTER_W,
D3D_TEST_RASTER_H, D3D_TEST_RASTER_W*4, 4);
J2dTraceLn(J2D_TRACE_VERBOSE, "D3D Raster:");
TestRasterOutput(rasPtr, 0, 0, D3D_TEST_RASTER_W,
D3D_TEST_RASTER_H, scanStride, pixelStride);
J2dTraceLn(J2D_TRACE_VERBOSE, "Deltas (x indicates problem pixel):");
TestRasterOutput(rasPtr, 0, 0, D3D_TEST_RASTER_W,
D3D_TEST_RASTER_H, scanStride, pixelStride,
goldenArray);
#endif // DEBUG
lpPlainSurface->Unlock(NULL);
return J2D_D3D_FAILURE;
}
}
}
lpPlainSurface->Unlock(NULL);
return (J2D_D3D_LINES_OK | J2D_D3D_LINE_CLIPPING_OK);
}
int TestLineRenderingQuality(JNIEnv *env, D3DContext *d3dContext,
DDrawSurface *lpPlainSurface)
{
static J2D_XY_C_VERTEX lineVerts[] = {
#ifdef USE_SINGLE_VERTEX_FORMAT
{ 0, 0, 0, 0xffffffff, 0.0f, 0.0f },
{ 0, 0, 0, 0xffffffff, 0.0f, 0.0f },
{ 0, 0, 0, 0xffffffff, 0.0f, 0.0f },
{ 0, 0, 0, 0xffffffff, 0.0f, 0.0f },
{ 0, 0, 0, 0xffffffff, 0.0f, 0.0f },
#else
{ 0, 0, 0, 0xffffffff }, // x, y, z, color
{ 0, 0, 0, 0xffffffff },
{ 0, 0, 0, 0xffffffff },
{ 0, 0, 0, 0xffffffff },
{ 0, 0, 0, 0xffffffff },
#endif // USE_SINGLE_VERTEX_FORMAT
};
IDirect3DDevice7 *d3dDevice = d3dContext->Get3DDevice();
HRESULT res;
d3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, 0x0, 0.0, 0);
if (FAILED(d3dContext->BeginScene(STATE_RENDEROP))) {
return J2D_D3D_FAILURE;
}
int i;
for (i = 0; i < d3dNumTestLines * 4; i += 4) {
lineVerts[0].x = d3dTestLines[i + 0];
lineVerts[0].y = d3dTestLines[i + 1];
lineVerts[1].x = d3dTestLines[i + 2];
lineVerts[1].y = d3dTestLines[i + 3];
if (FAILED(res = d3dDevice->DrawPrimitive(D3DPT_LINESTRIP,
D3DFVF_J2D_XY_C,
lineVerts, 2, 0)))
{
d3dContext->ForceEndScene();
return J2D_D3D_FAILURE;
}
// REMIND: needed for the test to pass on ATI some boards
d3dDevice->DrawPrimitive(D3DPT_POINTLIST, D3DFVF_J2D_XY_C,
&(lineVerts[1]), 1, 0);
}
for (i = 0; i < d3dNumTestRects * 4; i += 4) {
float x1 = d3dTestRects[i + 0];
float y1 = d3dTestRects[i + 1];
float x2 = d3dTestRects[i + 2];
float y2 = d3dTestRects[i + 3];
D3DU_INIT_VERTEX_PENT_XY(lineVerts, x1, y1, x2, y2);
if (FAILED(res = d3dDevice->DrawPrimitive(D3DPT_LINESTRIP,
D3DFVF_J2D_XY_C,
lineVerts, 5, 0)))
{
d3dContext->ForceEndScene();
return J2D_D3D_FAILURE;
}
}
d3dContext->ForceEndScene();
// REMIND: add rendering of clipped lines
return TestRenderingResults(lpPlainSurface, d3dTestRaster);
}
int TestTextureMappingQuality(JNIEnv *env, DDraw *ddObject,
D3DContext *d3dContext,
DDrawSurface *lpPlainSurface)
{
static J2DLVERTEX quadVerts[4] = {
{ 0.0f, 0.0f, 0.0f, 0xffffffff, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0xffffffff, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0xffffffff, 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0xffffffff, 0.0f, 0.0f }
};
int testRes = TestTextureFormats(d3dContext);
if (testRes & J2D_D3D_PIXEL_FORMATS_OK) {
DDrawSurface *lpTexture =
D3DUtils_CreateTexture(env, ddObject, d3dContext, TR_TRANSLUCENT,
D3D_TEXTURE_RASTER_W, D3D_TEXTURE_RASTER_H);
if (lpTexture) {
D3DUtils_UploadIntImageToXRGBTexture(lpTexture,
(int *)srcImageArray,
D3D_TEXTURE_RASTER_W,
D3D_TEXTURE_RASTER_H);
float u2 = ((float)D3D_TEXTURE_RASTER_W) /
(float)lpTexture->GetDXSurface()->GetWidth();
float v2 = ((float)D3D_TEXTURE_RASTER_H) /
(float)lpTexture->GetDXSurface()->GetHeight();
D3DU_INIT_VERTEX_QUAD_UV(quadVerts, 0.0f, 0.0f, u2, v2);
IDirect3DDevice7 *d3dDevice = d3dContext->Get3DDevice();
d3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, 0x00000000, 0.0, 0);
d3dContext->SetAlphaComposite(3/*SrcOver*/,
1.0f, D3DC_NO_CONTEXT_FLAGS);
d3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_POINT);
d3dDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTFG_POINT);
HRESULT res;
if (SUCCEEDED(res = d3dContext->BeginScene(STATE_BLITOP))) {
DXSurface *dxSurface = lpTexture->GetDXSurface();
if (SUCCEEDED(d3dContext->SetTexture(dxSurface))) {
for (int i = 0; i < d3dNumTextureRects * 4; i += 4) {
float x1 = d3dTextureRects[i + 0];
float y1 = d3dTextureRects[i + 1];
float x2 = d3dTextureRects[i + 2];
float y2 = d3dTextureRects[i + 3];
D3DU_INIT_VERTEX_QUAD_XY(quadVerts, x1, y1, x2, y2);
d3dDevice->DrawPrimitive(D3DPT_TRIANGLEFAN,
D3DFVF_J2DLVERTEX,
quadVerts, 4, 0);
}
}
res = d3dContext->ForceEndScene();
d3dContext->SetTexture(NULL);
}
// REMIND: at this point we ignore the results of
// the test.
TestRenderingResults(lpPlainSurface, linInterpArray);
if (SUCCEEDED(res)) {
testRes |= (J2D_D3D_TR_TEXTURE_SURFACE_OK |
J2D_D3D_TEXTURE_BLIT_OK |
J2D_D3D_TEXTURE_TRANSFORM_OK);
// REMIND: add tests for opaque and bitmask textures
testRes |= (J2D_D3D_OP_TEXTURE_SURFACE_OK |
J2D_D3D_BM_TEXTURE_SURFACE_OK);
}
delete lpTexture;
} else {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"TestTextureMappingQuality: "\
"CreateTexture(TRANSLUCENT) FAILED");
}
}
return testRes;
}
int TestD3DDevice(DDraw *ddObject,
D3DContext *d3dContext,
DxCapabilities *dxCaps)
{
int testRes = TestForBadHardware(dxCaps);
if (!(testRes & J2D_D3D_HW_OK) || !d3dContext) {
return testRes;
}
D3DDEVICEDESC7 d3dDevDesc;
IDirect3DDevice7 *d3dDevice = d3dContext->Get3DDevice();
if (d3dDevice == NULL ||
FAILED(d3dDevice->GetCaps(&d3dDevDesc)) ||
FAILED(D3DUtils_CheckDeviceCaps(&d3dDevDesc)))
{
J2dRlsTraceLn(J2D_TRACE_ERROR,
"TestD3DDevice: device caps testing FAILED");
return testRes;
}
testRes |= J2D_D3D_DEVICE_OK;
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
DDrawSurface *lpPlainSurface =
D3DUtils_CreatePlainSurface(env, ddObject, d3dContext,
D3D_TEST_RASTER_W, D3D_TEST_RASTER_H);
if (!lpPlainSurface) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"TestD3DDevice: CreatePlainSurface FAILED");
return testRes;
}
testRes |= J2D_D3D_PLAIN_SURFACE_OK;
// Set identity transform
if (FAILED(d3dContext->SetTransform(NULL, 0, 0, 0, 0, 0, 0))) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"TestD3DDevice: SetTransform FAILED");
delete lpPlainSurface;
return testRes;
}
testRes |= J2D_D3D_SET_TRANSFORM_OK;
// Test setting the target surface, create depth buffer, and
// clip
testRes |= TestSetClip(env, d3dContext, lpPlainSurface);
if (!(testRes & J2D_D3D_DEPTH_SURFACE_OK)) {
J2dRlsTraceLn(J2D_TRACE_ERROR, "TestD3DDevice: SetClip FAILED");
delete lpPlainSurface;
return testRes;
}
// Test drawLines
testRes |= TestLineRenderingQuality(env, d3dContext, lpPlainSurface);
// Test texture mapping
testRes |= TestTextureMappingQuality(env, ddObject, d3dContext,
lpPlainSurface);
d3dContext->SetRenderTarget(NULL);
delete lpPlainSurface;
return testRes;
}
#ifdef DEBUG
/**
* Output test raster (produced in D3DTest function). Utility
* used in debugging only. Enable by setting J2D_TRACE_LEVEL=J2D_VERBOSE
* prior to running application with debug java. The output from this will
* be seen only if D3DTest fails.
*/
void TestRasterOutput(byte *rasPtr, int x, int y, int w, int h,
int scanStride, int pixelStride,
TIntTestRaster goldenArray)
{
int goldenValue;
for (int traceRow = y; traceRow < h; ++traceRow) {
byte *tmpRasPtr = rasPtr + traceRow * scanStride;
for (int traceCol = x; traceCol < w; ++traceCol) {
DWORD pixelVal;
switch (pixelStride) {
case 1:
pixelVal = *tmpRasPtr;
break;
case 2:
pixelVal = *((unsigned short*)tmpRasPtr);
break;
default:
pixelVal = *((unsigned int*)tmpRasPtr) & 0x00ffffff;
break;
}
tmpRasPtr += pixelStride;
if (goldenArray == NULL) {
if (pixelVal) {
J2dTrace(J2D_TRACE_VERBOSE, "1");
} else {
J2dTrace(J2D_TRACE_VERBOSE, "0");
}
} else {
goldenValue = (goldenArray[traceRow][traceCol] & 0x00ffffff);
if ((goldenValue == 0 && pixelVal != 0) ||
(goldenValue != 0 && pixelVal == 0))
{
J2dTrace(J2D_TRACE_VERBOSE, "x");
} else {
J2dTrace(J2D_TRACE_VERBOSE, "-");
}
}
}
J2dTrace(J2D_TRACE_VERBOSE, "\n");
}
}
#endif // DEBUG
void PrintD3DCaps(int caps)
{
J2dTraceLn(J2D_TRACE_VERBOSE, "{")
if (caps == J2D_D3D_FAILURE) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_FAILURE");
} else {
if (caps & J2D_D3D_DEPTH_SURFACE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_DEPTH_SURFACE_OK,");
}
if (caps & J2D_D3D_PLAIN_SURFACE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_PLAIN_SURFACE_OK,");
}
if (caps & J2D_D3D_OP_TEXTURE_SURFACE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_OP_TEXTURE_SURFACE_OK,");
}
if (caps & J2D_D3D_BM_TEXTURE_SURFACE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_BM_TEXTURE_SURFACE_OK,");
}
if (caps & J2D_D3D_TR_TEXTURE_SURFACE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_TR_TEXTURE_SURFACE_OK,");
}
if (caps & J2D_D3D_OP_RTT_SURFACE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_OP_RTT_SURFACE_OK,");
}
if (caps & J2D_D3D_LINE_CLIPPING_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_LINE_CLIPPING_OK,");
}
if (caps & J2D_D3D_LINES_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_LINES_OK,");
}
if (caps & J2D_D3D_TEXTURE_BLIT_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_TEXTURE_BLIT_OK,");
}
if (caps & J2D_D3D_TEXTURE_TRANSFORM_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_TEXTURE_TRANSFORM_OK,");
}
if (caps & J2D_D3D_DEVICE_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_DEVICE_OK,");
}
if (caps & J2D_D3D_PIXEL_FORMATS_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_SET_TRANSFORM_OK,");
}
if (caps & J2D_D3D_HW_OK) {
J2dTraceLn(J2D_TRACE_VERBOSE, " J2D_D3D_HW_OK,");
}
}
J2dTraceLn(J2D_TRACE_VERBOSE, "}");
}