382 lines
15 KiB
C++
382 lines
15 KiB
C++
/*
|
|
* Copyright (C) 2018-2022 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#define _GDI32_ //It causes that definitions of functions are not loaded from dll in file wingdi.h because they are in this file.
|
|
|
|
#include "opencl/test/unit_test/helpers/windows/mock_function.h"
|
|
#include "opencl/test/unit_test/mocks/gl/windows/mock_gl_sharing_windows.h"
|
|
|
|
#include "GL/gl.h"
|
|
|
|
#include <string.h>
|
|
|
|
extern "C" {
|
|
const char *glString = "Intel";
|
|
const char *glVersion = "4.0";
|
|
const char *arrayStringi[2]{"GL_OES_framebuffer_object", "GL_EXT_framebuffer_object"};
|
|
int GLAcquireSharedBufferCalled = 0;
|
|
int GLAcquireSharedRenderBufferCalled = 0;
|
|
int GLAcquireSharedTextureCalled = 0;
|
|
int GLDeleteContextCalled = 0;
|
|
int GLGetCurrentContextCalled = 0;
|
|
int GLGetCurrentDisplayCalled = 0;
|
|
int GLGetSyncivCalled = 0;
|
|
int GLMakeCurrentCalled = 0;
|
|
int GLReleaseSharedBufferCalled = 0;
|
|
int GLReleaseSharedRenderBufferCalled = 0;
|
|
int GLReleaseSharedTextureCalled = 0;
|
|
int GLReleaseSyncCalled = 0;
|
|
int GLRetainSyncCalled = 0;
|
|
int WGLCreateContextCalled = 0;
|
|
int WGLDeleteContextCalled = 0;
|
|
int WGLShareListsCalled = 0;
|
|
CL_GL_BUFFER_INFO bufferInfoInput = {0};
|
|
CL_GL_BUFFER_INFO bufferInfoOutput = {0};
|
|
CL_GL_RESOURCE_INFO textureInfoInput = {0};
|
|
CL_GL_RESOURCE_INFO textureInfoOutput = {0};
|
|
NEO::GLMockReturnedValues glMockReturnedValues = {0};
|
|
GLboolean GLSetSharedOCLContextStateReturnedValue = 1u;
|
|
bool glGetLuidFuncAvailable = true;
|
|
int glGetLuidCalled = 0;
|
|
|
|
const unsigned char *WINAPI glGetString(unsigned int name) {
|
|
if (name == GL_VENDOR)
|
|
return reinterpret_cast<const unsigned char *>(glString);
|
|
if (name == GL_VERSION)
|
|
return reinterpret_cast<const unsigned char *>(glVersion);
|
|
return reinterpret_cast<const unsigned char *>("");
|
|
};
|
|
GLboolean WINAPI wglSetSharedOCLContextStateINTELMock(HDC HDCHandle, HGLRC ContextHandle, unsigned char State,
|
|
void *pContextInfo) {
|
|
((NEO::ContextInfo *)pContextInfo)->ContextHandle = 1;
|
|
((NEO::ContextInfo *)pContextInfo)->DeviceHandle = 2;
|
|
return GLSetSharedOCLContextStateReturnedValue;
|
|
};
|
|
GLboolean WINAPI mockGLAcquireSharedBuffer(GLDisplay, GLContext, GLContext, GLvoid *pResourceInfo) {
|
|
|
|
auto pBufferInfo = (CL_GL_BUFFER_INFO *)pResourceInfo;
|
|
bufferInfoInput = *pBufferInfo;
|
|
pBufferInfo->bufferSize = bufferInfoOutput.bufferSize;
|
|
pBufferInfo->globalShareHandle = bufferInfoOutput.globalShareHandle;
|
|
pBufferInfo->pGmmResInfo = bufferInfoOutput.pGmmResInfo;
|
|
pBufferInfo->bufferOffset = bufferInfoOutput.bufferOffset;
|
|
GLAcquireSharedBufferCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
GLboolean WINAPI mockGLReleaseSharedBuffer(GLDisplay, GLContext, GLContext, GLvoid *pResourceInfo) {
|
|
bufferInfoInput = *static_cast<CL_GL_BUFFER_INFO *>(pResourceInfo);
|
|
GLReleaseSharedBufferCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
GLboolean WINAPI mockGLAcquireSharedRenderBuffer(GLDisplay, GLContext, GLContext, GLvoid *pResourceInfo) {
|
|
auto pTextureInfo = (CL_GL_RESOURCE_INFO *)pResourceInfo;
|
|
textureInfoInput = *pTextureInfo;
|
|
pTextureInfo->globalShareHandle = textureInfoOutput.globalShareHandle;
|
|
pTextureInfo->pGmmResInfo = textureInfoOutput.pGmmResInfo;
|
|
pTextureInfo->glInternalFormat = GL_RGBA8;
|
|
GLAcquireSharedRenderBufferCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
GLboolean WINAPI mockGLReleaseSharedRenderBuffer(GLDisplay, GLContext, GLContext, GLvoid *pResourceInfo) {
|
|
textureInfoInput = *static_cast<CL_GL_RESOURCE_INFO *>(pResourceInfo);
|
|
GLReleaseSharedRenderBufferCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
GLboolean WINAPI mockGLAcquireSharedTexture(GLDisplay, GLContext, GLContext, GLvoid *pResourceInfo) {
|
|
auto pTextureInfo = (CL_GL_RESOURCE_INFO *)pResourceInfo;
|
|
textureInfoInput = *pTextureInfo;
|
|
pTextureInfo->globalShareHandle = textureInfoOutput.globalShareHandle;
|
|
pTextureInfo->globalShareHandleMCS = textureInfoOutput.globalShareHandleMCS;
|
|
if (pTextureInfo->target == GL_TEXTURE_BUFFER) {
|
|
// size and width for texture buffer are queried from textureInfo - not from gmm
|
|
pTextureInfo->textureBufferSize = textureInfoOutput.textureBufferSize;
|
|
pTextureInfo->textureBufferWidth = textureInfoOutput.textureBufferWidth;
|
|
}
|
|
pTextureInfo->pGmmResInfo = textureInfoOutput.pGmmResInfo;
|
|
pTextureInfo->glInternalFormat = textureInfoOutput.glInternalFormat ? textureInfoOutput.glInternalFormat : GL_RGBA8;
|
|
pTextureInfo->glHWFormat = textureInfoOutput.glHWFormat;
|
|
pTextureInfo->textureBufferOffset = textureInfoOutput.textureBufferOffset;
|
|
pTextureInfo->numberOfSamples = textureInfoOutput.numberOfSamples;
|
|
pTextureInfo->isAuxEnabled = textureInfoOutput.isAuxEnabled;
|
|
GLAcquireSharedTextureCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
GLboolean WINAPI mockGLReleaseSharedTexture(GLDisplay, GLContext, GLContext, GLvoid *pResourceInfo) {
|
|
textureInfoInput = *static_cast<CL_GL_RESOURCE_INFO *>(pResourceInfo);
|
|
GLReleaseSharedTextureCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
GLboolean WINAPI mockGlRetainSync(GLDisplay HDCHandle, GLContext ContextHandle, GLContext BackupContextHandle,
|
|
GLvoid *pSyncInfo) {
|
|
GLRetainSyncCalled++;
|
|
GL_CL_SYNC_INFO *syncInfo = (GL_CL_SYNC_INFO *)(pSyncInfo);
|
|
syncInfo->pSync = (void *)0x123;
|
|
return GL_TRUE;
|
|
};
|
|
GLboolean WINAPI mockGlReleaseSync(GLDisplay HDCHandle, GLContext ContextHandle, GLContext BackupContextHandle,
|
|
GLvoid *pSync) {
|
|
GLReleaseSyncCalled++;
|
|
return GL_TRUE;
|
|
};
|
|
void WINAPI mockGlGetSynciv(GLvoid *pSync, GLenum pname, GLint *value) {
|
|
GLGetSyncivCalled++;
|
|
*value = glMockReturnedValues.syncivRetVal;
|
|
};
|
|
const unsigned char *_stdcall glGetStringiMock(unsigned int name, unsigned int index) { return reinterpret_cast<const unsigned char *>(arrayStringi[index]); };
|
|
GLDisplay WINAPI mockGLGetCurrentDisplay() {
|
|
GLGetCurrentDisplayCalled++;
|
|
return glMockReturnedValues.currentDisplay;
|
|
};
|
|
|
|
LUID WINAPI wglGetLuidMock(GLContext glContext) {
|
|
glGetLuidCalled++;
|
|
LUID luid{};
|
|
if (reinterpret_cast<GLContext>(1) == glContext) {
|
|
luid.HighPart = 0x1d2e;
|
|
luid.LowPart = 0x3f4a;
|
|
} else if (reinterpret_cast<GLContext>(2) == glContext) {
|
|
luid.HighPart = 0x5d2e;
|
|
luid.LowPart = 0x3f4a;
|
|
}
|
|
return luid;
|
|
};
|
|
|
|
PROC WINAPI wglGetProcAddress(LPCSTR name) {
|
|
if (strcmp(name, "wglSetSharedOCLContextStateINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*wglSetSharedOCLContextStateINTELMock);
|
|
}
|
|
if (strcmp(name, "wglAcquireSharedBufferINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGLAcquireSharedBuffer);
|
|
}
|
|
if (strcmp(name, "wglReleaseSharedBufferINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGLReleaseSharedBuffer);
|
|
}
|
|
if (strcmp(name, "wglAcquireSharedRenderBufferINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGLAcquireSharedRenderBuffer);
|
|
}
|
|
if (strcmp(name, "wglReleaseSharedRenderBufferINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGLReleaseSharedRenderBuffer);
|
|
}
|
|
if (strcmp(name, "wglAcquireSharedTextureINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGLAcquireSharedTexture);
|
|
}
|
|
if (strcmp(name, "wglReleaseSharedTextureINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGLReleaseSharedTexture);
|
|
}
|
|
if (strcmp(name, "wglRetainSyncINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGlRetainSync);
|
|
}
|
|
if (strcmp(name, "wglReleaseSyncINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGlReleaseSync);
|
|
}
|
|
if (strcmp(name, "wglGetSyncivINTEL") == 0) {
|
|
return reinterpret_cast<PROC>(*mockGlGetSynciv);
|
|
}
|
|
if (strcmp(name, "glGetStringi") == 0) {
|
|
return reinterpret_cast<PROC>(*glGetStringiMock);
|
|
}
|
|
if (strcmp(name, "wglGetLuidINTEL") == 0 && glGetLuidFuncAvailable) {
|
|
return reinterpret_cast<PROC>(wglGetLuidMock);
|
|
}
|
|
return nullptr;
|
|
}
|
|
HGLRC WINAPI wglGetCurrentContext() {
|
|
GLGetCurrentContextCalled++;
|
|
return glMockReturnedValues.currentContext;
|
|
};
|
|
HDC WINAPI wglGetCurrentDC() { return mockGLGetCurrentDisplay(); };
|
|
HGLRC WINAPI wglCreateContext(HDC Arg1) {
|
|
WGLCreateContextCalled++;
|
|
return (GLContext)0x101;
|
|
};
|
|
BOOL WINAPI wglDeleteContext(HGLRC Arg1) {
|
|
WGLDeleteContextCalled++;
|
|
GLDeleteContextCalled++;
|
|
return (GLboolean)1;
|
|
};
|
|
void WINAPI glGetIntegerv(GLenum pname, GLint *params) { return NEO::MockGLSharingFunctions::glGetIntegervTest(pname, params); };
|
|
BOOL WINAPI wglShareLists(HGLRC arg1, HGLRC arg2) {
|
|
WGLShareListsCalled++;
|
|
return 1;
|
|
};
|
|
|
|
BOOL WINAPI wglMakeCurrent(HDC arg1, HGLRC arg2) {
|
|
GLMakeCurrentCalled++;
|
|
glMockReturnedValues.madeCurrentContext = arg2;
|
|
if (glMockReturnedValues.forceMakeCurrentCallFail) {
|
|
if (glMockReturnedValues.failsCounter < glMockReturnedValues.numberOfCallFails) {
|
|
glMockReturnedValues.failsCounter++;
|
|
return GL_FALSE;
|
|
}
|
|
}
|
|
return (GLboolean)1;
|
|
};
|
|
void *WINAPI mockLoader(const char *name) {
|
|
if (strcmp(name, "realFunction") == 0) {
|
|
return *realFunction;
|
|
}
|
|
return nullptr;
|
|
};
|
|
void resetParam(const char *name) {
|
|
if (strcmp(name, "GLAcquireSharedBufferCalled") == 0) {
|
|
GLAcquireSharedBufferCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLAcquireSharedRenderBufferCalled") == 0) {
|
|
GLAcquireSharedRenderBufferCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLAcquireSharedTextureCalled") == 0) {
|
|
GLAcquireSharedTextureCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLDeleteContextCalled") == 0) {
|
|
GLDeleteContextCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLGetCurrentContextCalled") == 0) {
|
|
GLGetCurrentContextCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLGetCurrentDisplayCalled") == 0) {
|
|
GLGetCurrentDisplayCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLGetSyncivCalled") == 0) {
|
|
GLGetSyncivCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLMakeCurrentCalled") == 0) {
|
|
GLMakeCurrentCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLReleaseSharedBufferCalled") == 0) {
|
|
GLReleaseSharedBufferCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLReleaseSharedRenderBufferCalled") == 0) {
|
|
GLReleaseSharedRenderBufferCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLReleaseSharedTextureCalled") == 0) {
|
|
GLReleaseSharedTextureCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLReleaseSyncCalled") == 0) {
|
|
GLReleaseSyncCalled = 0;
|
|
}
|
|
if (strcmp(name, "GLRetainSyncCalled") == 0) {
|
|
GLRetainSyncCalled = 0;
|
|
}
|
|
if (strcmp(name, "WGLCreateContextCalled") == 0) {
|
|
WGLCreateContextCalled = 0;
|
|
}
|
|
if (strcmp(name, "WGLDeleteContextCalled") == 0) {
|
|
WGLDeleteContextCalled = 0;
|
|
}
|
|
if (strcmp(name, "WGLShareListsCalled") == 0) {
|
|
WGLShareListsCalled = 0;
|
|
}
|
|
if (strcmp(name, "") == 0) {
|
|
GLAcquireSharedBufferCalled = 0;
|
|
GLAcquireSharedRenderBufferCalled = 0;
|
|
GLAcquireSharedTextureCalled = 0;
|
|
GLDeleteContextCalled = 0;
|
|
GLGetCurrentContextCalled = 0;
|
|
GLGetCurrentDisplayCalled = 0;
|
|
GLGetSyncivCalled = 0;
|
|
GLMakeCurrentCalled = 0;
|
|
GLReleaseSharedBufferCalled = 0;
|
|
GLReleaseSharedRenderBufferCalled = 0;
|
|
GLReleaseSharedTextureCalled = 0;
|
|
GLReleaseSyncCalled = 0;
|
|
GLRetainSyncCalled = 0;
|
|
WGLCreateContextCalled = 0;
|
|
WGLDeleteContextCalled = 0;
|
|
WGLShareListsCalled = 0;
|
|
glGetLuidCalled = 0;
|
|
glGetLuidFuncAvailable = true;
|
|
}
|
|
if (strcmp(name, "glGetLuidCalled") == 0) {
|
|
glGetLuidCalled = 0;
|
|
}
|
|
if (strcmp(name, "glGetLuidFuncAvailable") == 0) {
|
|
glGetLuidFuncAvailable = true;
|
|
}
|
|
if (strcmp(name, "glGetLuidFuncNotAvailable") == 0) {
|
|
glGetLuidFuncAvailable = false;
|
|
}
|
|
};
|
|
int getParam(const char *name) {
|
|
if (strcmp(name, "GLAcquireSharedBufferCalled") == 0) {
|
|
return GLAcquireSharedBufferCalled;
|
|
}
|
|
if (strcmp(name, "GLAcquireSharedRenderBufferCalled") == 0) {
|
|
return GLAcquireSharedRenderBufferCalled;
|
|
}
|
|
if (strcmp(name, "GLAcquireSharedTextureCalled") == 0) {
|
|
return GLAcquireSharedTextureCalled;
|
|
}
|
|
if (strcmp(name, "GLDeleteContextCalled") == 0) {
|
|
return GLDeleteContextCalled;
|
|
}
|
|
if (strcmp(name, "GLGetCurrentContextCalled") == 0) {
|
|
return GLGetCurrentContextCalled;
|
|
}
|
|
if (strcmp(name, "GLGetCurrentDisplayCalled") == 0) {
|
|
return GLGetCurrentDisplayCalled;
|
|
}
|
|
if (strcmp(name, "GLGetSyncivCalled") == 0) {
|
|
return GLGetSyncivCalled;
|
|
}
|
|
if (strcmp(name, "GLMakeCurrentCalled") == 0) {
|
|
return GLMakeCurrentCalled;
|
|
}
|
|
if (strcmp(name, "GLReleaseSharedBufferCalled") == 0) {
|
|
return GLReleaseSharedBufferCalled;
|
|
}
|
|
if (strcmp(name, "GLReleaseSharedRenderBufferCalled") == 0) {
|
|
return GLReleaseSharedRenderBufferCalled;
|
|
}
|
|
if (strcmp(name, "GLReleaseSharedTextureCalled") == 0) {
|
|
return GLReleaseSharedTextureCalled;
|
|
}
|
|
if (strcmp(name, "GLReleaseSyncCalled") == 0) {
|
|
return GLReleaseSyncCalled;
|
|
}
|
|
if (strcmp(name, "GLRetainSyncCalled") == 0) {
|
|
return GLRetainSyncCalled;
|
|
}
|
|
if (strcmp(name, "WGLCreateContextCalled") == 0) {
|
|
return WGLCreateContextCalled;
|
|
}
|
|
if (strcmp(name, "WGLDeleteContextCalled") == 0) {
|
|
return WGLDeleteContextCalled;
|
|
}
|
|
if (strcmp(name, "WGLShareListsCalled") == 0) {
|
|
return WGLShareListsCalled;
|
|
}
|
|
if (strcmp(name, "glGetLuidCalled") == 0) {
|
|
return glGetLuidCalled;
|
|
}
|
|
return 0;
|
|
};
|
|
CL_GL_BUFFER_INFO getBufferInfo() { return bufferInfoInput; };
|
|
CL_GL_RESOURCE_INFO getTextureInfo() { return textureInfoInput; };
|
|
void memParam() {
|
|
memset(&bufferInfoInput, 0, sizeof(CL_GL_BUFFER_INFO));
|
|
memset(&bufferInfoOutput, 0, sizeof(CL_GL_BUFFER_INFO));
|
|
memset(&textureInfoInput, 0, sizeof(CL_GL_RESOURCE_INFO));
|
|
memset(&textureInfoOutput, 0, sizeof(CL_GL_RESOURCE_INFO));
|
|
memset(&glMockReturnedValues, 0, sizeof(NEO::GLMockReturnedValues));
|
|
};
|
|
void loadBuffer(CL_GL_BUFFER_INFO buff) { bufferInfoOutput = buff; };
|
|
void loadTexture(CL_GL_RESOURCE_INFO texture) { textureInfoOutput = texture; };
|
|
NEO::GLMockReturnedValues getGlMockReturnedValues() { return glMockReturnedValues; };
|
|
void setGlMockReturnedValues(NEO::GLMockReturnedValues value) { glMockReturnedValues = value; };
|
|
void setGetSyncivReturnValue(int val) { glMockReturnedValues.syncivRetVal = val; }
|
|
void glSetString(const char *name, unsigned int var) {
|
|
if (var == GL_VENDOR) {
|
|
glString = name;
|
|
} else if (var == GL_VERSION) {
|
|
glVersion = name;
|
|
}
|
|
};
|
|
void glSetStringi(const char *name, unsigned int index) { arrayStringi[index] = name; };
|
|
void setGLSetSharedOCLContextStateReturnedValue(GLboolean value) { GLSetSharedOCLContextStateReturnedValue = static_cast<GLboolean>(value); };
|
|
GLboolean getGLSetSharedOCLContextStateReturnedValue() { return GLSetSharedOCLContextStateReturnedValue; };
|
|
}
|