int
main(
int argc,
char * argv[]
)
{
gctBOOL dumpLog = gcvFALSE;
gctSTRING fileName[2] = { gcvNULL, gcvNULL };
gcSHADER shaders[2] = { gcvNULL, gcvNULL };
gctINT i;
gcoOS os = gcvNULL;
gcoHAL hal = gcvNULL;
gceSTATUS result;
gctUINT option = 1; /* no optimization */
char outFile[128] = { '\0' };
char logVSFile[128] = { '\0' };
char logFSFile[128] = { '\0' };
printf("vCompile version 0.8, Copyright (c) 2005-2011, Vivante Corporation\n\n");
#ifdef _WIN32
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) /*| _CRTDBG_CHECK_ALWAYS_DF*/ | _CRTDBG_DELAY_FREE_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
/* _CrtSetBreakAlloc(79); */
#endif
#if gcdDEBUG
gcoOS_SetDebugLevel(gcvLEVEL_VERBOSE);
gcoOS_SetDebugZone(gcvZONE_COMPILER);
#endif
for (i = 1; i < argc; i++)
{
if (gcmIS_SUCCESS(gcoOS_StrCmp(argv[i], "-l")))
{
dumpLog = gcvTRUE;
}
else if (gcmIS_SUCCESS(gcoOS_StrCmp(argv[i], "-O0")))
{
/* Currently, optimization level is either FULL or NONE */
option = 0; /* no optimization */
}
else if (gcmIS_SUCCESS(gcoOS_StrCmp(argv[i], "-O")))
{
option = 1; /* full optimization */
}
else if (gcmIS_SUCCESS(gcoOS_StrCmp(argv[i], "-OT")))
{
/* For optimization unit test */
if (i++ == argc)
{
printf("*ERROR* Optimization testing pattern not provided.\n");
return 1;
}
else
{
gctINT testPattern;
gcmVERIFY_OK(gcoOS_StrToInt(argv[i], (gctINT *)&testPattern));
if (testPattern < 0)
{
printf("*ERROR* Unknown optimization testing pattern.\n");
return 1;
}
option = testPattern;
}
}
else
{
if (fileName[0] == gcvNULL) fileName[0] = argv[i];
else if (fileName[1] == gcvNULL) fileName[1] = argv[i];
else
{
printf("*ERROR* Too many shaders.\n");
return 1;
}
}
}
if (fileName[0] == gcvNULL)
{
printf("Usage: %s [-l] [-O0] shaderFileName [shaderFileName]\n", argv[0]);
printf(" -l Generate log file.\n"
" -O0 Disable optimizations.\n"
"\n"
"If only one shader is specified, that shader will be compiled into a .gcSL\n"
"file. If two shaders are specified, those shaders will be compiled and\n"
"linked into a .gcPGM file. With two shaders, the vertex shader file needs\n"
"to be the first.\n");
return 0;
}
result = gcoOS_Construct(gcvNULL, &os);
if (result != gcvSTATUS_OK)
{
printf("*ERROR* Failed to construct a new gcoOS object\n");
return 1;
}
result = gcoHAL_Construct(gcvNULL, os, &hal);
if (result != gcvSTATUS_OK)
{
printf("*ERROR* Failed to construct a new gcoHAL object\n");
goto ErrorExit;
}
/* Dump compile log only when one shader is present */
shaders[0] = CompileFile(os, fileName[0], hal, option, dumpLog && (fileName[1] == gcvNULL), fileName[1] == gcvNULL );
if (shaders[0] == gcvNULL)
{
goto ErrorExit;
}
if (fileName[1] != gcvNULL)
{
gctSIZE_T programBufferSize = 0;
gctPOINTER programBuffer = gcvNULL;
gcsHINT_PTR hints = gcvNULL;
gceSTATUS status;
gctPOINTER binary = gcvNULL;
gctSIZE_T binarySize = 0;
FILE * f;
gctSTRING p;
gcoOS_StrCopySafe(outFile, gcmSIZEOF(outFile), fileName[0]);
p = strrchr(outFile, '.');
gcoOS_StrCopySafe(p, gcmSIZEOF(outFile) - (p - outFile), ".gcPGM");
gcoOS_StrCopySafe(logVSFile, gcmSIZEOF(logVSFile), fileName[0]);
gcoOS_StrCatSafe(logVSFile, gcmSIZEOF(logVSFile), ".log");
gcoOS_StrCopySafe(logFSFile, gcmSIZEOF(logFSFile), fileName[1]);
gcoOS_StrCatSafe(logFSFile, gcmSIZEOF(logFSFile), ".log");
shaders[1] = CompileFile(os, fileName[1], hal, option, gcvFALSE, gcvFALSE);
if (shaders[1] == gcvNULL)
{
goto ErrorExit;
}
if ( dumpLog)
{
gcoOS_SetDebugShaderFiles(logVSFile, logFSFile);
}
status = gcLinkShaders(shaders[0],
shaders[1],
gcvSHADER_DEAD_CODE
| gcvSHADER_RESOURCE_USAGE
| gcvSHADER_OPTIMIZER
| gcvSHADER_USE_GL_Z
| gcvSHADER_USE_GL_POSITION
| gcvSHADER_USE_GL_FACE,
&programBufferSize,
&programBuffer,
&hints);
if ( dumpLog)
{
gcoOS_SetDebugShaderFiles(gcvNULL, gcvNULL);
}
if (gcmIS_ERROR(status))
{
printf("*ERROR* gcLinkShaders returned errror %d\n", status);
}
else
{
int ret;
status = gcSaveProgram(shaders[0],
shaders[1],
programBufferSize,
programBuffer,
hints,
&binary,
&binarySize);
if (gcmIS_ERROR(status))
{
printf("*ERROR* gcSaveShaders returned errror %d\n", status);
}
f = fopen(outFile, "wb");
ret = fwrite(binary, binarySize, 1, f);
if (ret);
fclose(f);
}
if (programBuffer != gcvNULL) gcoOS_Free(os, programBuffer);
if (hints != gcvNULL) gcoOS_Free(os, hints);
if (binary != gcvNULL) gcoOS_Free(os, binary);
}
gcSHADER_Destroy(shaders[0]);
if (shaders[1] != gcvNULL) gcSHADER_Destroy(shaders[1]);
gcoHAL_Destroy(hal);
gcoOS_Destroy(os);
return 0;
ErrorExit:
if (shaders[0] != gcvNULL) gcSHADER_Destroy(shaders[0]);
if (shaders[1] != gcvNULL) gcSHADER_Destroy(shaders[1]);
if (gcvNULL != hal) gcoHAL_Destroy(hal);
if (gcvNULL != os) gcoOS_Destroy(os);
return 1;
}
/**
*
* @param driver - Driver object to be returned
* @return the status of the initilization
*/
static gctBOOL SetupDriver
(
OUT Viv2DDriverPtr * driver
) {
TRACE_ENTER();
gceSTATUS status = gcvSTATUS_OK;
Viv2DDriverPtr pDrvHandle = gcvNULL;
gctPOINTER mHandle = gcvNULL;
/*Allocating the driver*/
gcmASSERT(*driver == gcvNULL);
status = gcoOS_Allocate(gcvNULL, sizeof (Viv2DDriver), &mHandle);
if (status < 0) {
TRACE_ERROR("Unable to allocate driver, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
pDrvHandle = (Viv2DDriverPtr) mHandle;
status = gcoOS_Construct(gcvNULL, &(pDrvHandle->mOs));
if (status < 0) {
TRACE_ERROR("Unable to construct OS object, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
status = gcoHAL_Construct(gcvNULL, pDrvHandle->mOs, &(pDrvHandle->mHal));
if (status < 0) {
TRACE_ERROR("Unable to construct HAL object, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
/*If Seperated*/
pDrvHandle->mIsSeperated = gcoHAL_QuerySeparated3D2D(pDrvHandle->mHal) == gcvSTATUS_TRUE;
if (pDrvHandle->mIsSeperated) {
status = gcoHAL_SetHardwareType(pDrvHandle->mHal, gcvHARDWARE_2D);
if (status < 0) {
TRACE_ERROR("Unable to gcoHAL_SetHardwareType, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
}
if (!gcoHAL_IsFeatureAvailable(pDrvHandle->mHal, gcvFEATURE_PIPE_2D)) {
TRACE_ERROR("2D PIPE IS NOT AVAIBLE");
TRACE_EXIT(gcvFALSE);
}
/* Query the amount of video memory. */
status = gcoHAL_QueryVideoMemory
(pDrvHandle->mHal,
&pDrvHandle->g_InternalPhysical,
&pDrvHandle->g_InternalSize,
&pDrvHandle->g_ExternalPhysical,
&pDrvHandle->g_ExternalSize,
&pDrvHandle->g_ContiguousPhysical,
&pDrvHandle->g_ContiguousSize
);
if (status < 0) {
TRACE_ERROR("gcoHAL_QueryVideoMemory failed, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
/* Map the local internal memory. */
if (pDrvHandle->g_InternalSize > 0) {
status = gcoHAL_MapMemory(
pDrvHandle->mHal,
pDrvHandle->g_InternalPhysical,
pDrvHandle-> g_InternalSize,
&pDrvHandle->g_Internal
);
if (status < 0) {
TRACE_ERROR("gcoHAL_MapMemory failed, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
}
/* Map the local external memory. */
if (pDrvHandle->g_ExternalSize > 0) {
status = gcoHAL_MapMemory(
pDrvHandle->mHal,
pDrvHandle->g_ExternalPhysical,
pDrvHandle->g_ExternalSize,
&pDrvHandle->g_External
);
if (status < 0) {
TRACE_ERROR("gcoHAL_MapMemory failed, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
}
/* Map the contiguous memory. */
if (pDrvHandle->g_ContiguousSize > 0) {
status = gcoHAL_MapMemory
(pDrvHandle->mHal,
pDrvHandle->g_ContiguousPhysical,
pDrvHandle->g_ContiguousSize,
&pDrvHandle->g_Contiguous
);
TRACE_INFO("Physcal : %d LOGICAL ADDR = %p SIZE = %d\n", pDrvHandle->g_ContiguousPhysical, pDrvHandle->g_Contiguous, pDrvHandle->g_ContiguousSize);
if (status < 0) {
TRACE_ERROR("gcoHAL_MapMemory failed, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
}
/* Determine whether PE 2.0 is present. */
pDrvHandle->mIsPe20Supported = gcoHAL_IsFeatureAvailable(pDrvHandle ->mHal,
gcvFEATURE_2DPE20)
== gcvSTATUS_TRUE;
/*Multi source options*/
pDrvHandle->mIsMultiSrcBltSupported = gcoHAL_IsFeatureAvailable(pDrvHandle->mHal, gcvFEATURE_2D_MULTI_SOURCE_BLT) == gcvSTATUS_TRUE;
pDrvHandle->mIsMultiSrcBltExSupported = gcoHAL_IsFeatureAvailable(pDrvHandle->mHal, gcvFEATURE_2D_MULTI_SOURCE_BLT_EX) == gcvSTATUS_TRUE;
pDrvHandle->mMaxSourceForMultiSrcOpt = pDrvHandle->mIsMultiSrcBltExSupported ? 8 : (pDrvHandle->mIsMultiSrcBltSupported ? 4 : 1);
/*Getting the 2d engine*/
status = gcoHAL_Get2DEngine(pDrvHandle->mHal, &(pDrvHandle->m2DEngine));
if (status < 0) {
TRACE_ERROR("Unable to construct 2DEngine object, status = %d\n", status);
TRACE_EXIT(gcvFALSE);
}
*driver = pDrvHandle;
TRACE_EXIT(gcvTRUE);
}
