int
UnsharpMask::runCLKernels()
{
int status;
try
{
if(!dImageBuffer)
{
// Set kernel arguments for 1st pass
status = unsharp_mask_pass1.setArg(0, inputImageObj);
status = unsharp_mask_pass1.setArg(1, tmpImageObj);
status = unsharp_mask_pass1.setArg(2, width);
status = unsharp_mask_pass1.setArg(3, gaussian1DBuffer);
status = unsharp_mask_pass1.setArg(4, radius);
//enqueue the two kernels
cl::NDRange globalThreads(width,height);
status = queue.enqueueNDRangeKernel(unsharp_mask_pass1,cl::NullRange,
globalThreads);
// Set kernel arguments 2nd pass
status = unsharp_mask_pass2.setArg(0, inputImageObj);
status = unsharp_mask_pass2.setArg(1, tmpImageObj);
status = unsharp_mask_pass2.setArg(2, sharpenImageObj);
status = unsharp_mask_pass2.setArg(3, width);
status = unsharp_mask_pass2.setArg(4, height);
status = unsharp_mask_pass2.setArg(5, gaussian1DBuffer);
status = unsharp_mask_pass2.setArg(6, radius);
status = unsharp_mask_pass2.setArg(7, threshold);
status = unsharp_mask_pass2.setArg(8, amount);
status = queue.enqueueNDRangeKernel(unsharp_mask_pass2,cl::NullRange,
globalThreads);
}
else
{
// Set kernel arguments 2nd pass
status = unsharp_mask_filter.setArg(0, inputBuffer);
status = unsharp_mask_filter.setArg(1, outputBuffer);
status = unsharp_mask_filter.setArg(2, width);
status = unsharp_mask_filter.setArg(3, height);
status = unsharp_mask_filter.setArg(4, gaussian2DBuffer);
status = unsharp_mask_filter.setArg(5, radius);
status = unsharp_mask_filter.setArg(6, threshold);
status = unsharp_mask_filter.setArg(7, amount);
cl::NDRange globalThreads(width,height);
status = queue.enqueueNDRangeKernel(unsharp_mask_filter,cl::NullRange,
globalThreads);
}
}
catch (cl::Error e)
{
std::cout << e.what() << std::endl;
std::cout << "Error code: " << e.err() << std::endl;
return SDK_FAILURE;
}
return SDK_SUCCESS;
}
void TestOpenCL::process()
{
//create opencl context and command queue
if(!initOpenCl())
return;
//create texture, must be done after openCl context created (at least for AMD)
if(!initTexture())
return;
//load and compile kernel
if(!initKernel())
return;
cl::Event event;
cl_int status;
cl::NDRange globalThreads(m_testImage.width(), m_testImage.height());
int pos=0;
int outputIndex=0;
while(m_process)
{
//setup kernel arguments
status=m_kernel.setArg(0, *m_testImage.image());
if(status != CL_SUCCESS)
assert(false);
status=m_kernel.setArg(1, *m_outputImage[outputIndex].image());
if(status != CL_SUCCESS)
assert(false);
status=m_kernel.setArg(2, pos);
if(status != CL_SUCCESS)
assert(false);
//execute kernel
status=m_openCLComandQueue.enqueueNDRangeKernel(m_kernel, cl::NullRange, globalThreads, cl::NullRange, NULL, &event);
if(status != CL_SUCCESS)
assert(false);
m_openCLComandQueue.flush();
pos++;
if(pos > m_testImage.width())
pos=0;
event.wait();
m_openCLComandQueue.finish();
m_mainView->display(&m_outputImage[outputIndex]);
m_auxView->display(&m_outputImage[outputIndex]);
outputIndex++;
if(outputIndex >= m_outputImage.size())
outputIndex=0;
}
m_openCLComandQueue.finish();
}
void zeroBuffer(::cl::Context &context, ::cl::CommandQueue &commandQueue, ::cl::Buffer &buffer, size_t size, std::vector<::cl::Event> *events, ::cl::Event &event)
{
cl_int status;
::cl::Kernel kernel=getKernel(context, "zeroMemory", "utils.cl", utils_cl);
status=kernel.setArg(0, buffer);
::cl::NDRange globalThreads(size);
status=commandQueue.enqueueNDRangeKernel(kernel, ::cl::NullRange, globalThreads, ::cl::NullRange, events, &event);
}
void zeroImage(::cl::Context &context, ::cl::CommandQueue &commandQueue, ::cl::Image2D &image, std::vector<::cl::Event> *events, ::cl::Event &event)
{
cl_int status;
size_t width, height;
::cl::Kernel kernel=getKernel(context, "zeroFloatImage", "utils.cl", utils_cl);
image.getImageInfo(CL_IMAGE_WIDTH, &width);
image.getImageInfo(CL_IMAGE_HEIGHT, &height);
status=kernel.setArg(0, image);
::cl::NDRange globalThreads(width, height);
status=commandQueue.enqueueNDRangeKernel(kernel, ::cl::NullRange, globalThreads, ::cl::NullRange, events, &event);
}
int SobelFilterImage::runCLKernels()
{
cl_int status;
cl::size_t<3> origin;
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
cl::size_t<3> region;
region[0] = width;
region[1] = height;
region[2] = 1;
cl::Event writeEvt;
status = commandQueue.enqueueWriteImage(
inputImage2D,
CL_TRUE,
origin,
region,
0,
0,
inputImageData,
NULL,
&writeEvt);
CHECK_OPENCL_ERROR(status,
"CommandQueue::enqueueWriteImage failed. (inputImage2D)");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
cl_int eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = writeEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status,
"cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
// Set appropriate arguments to the kernel
// input buffer image
status = kernel.setArg(0, inputImage2D);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (inputImageBuffer)");
// outBuffer imager
status = kernel.setArg(1, outputImage2D);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (outputImageBuffer)");
/*
* Enqueue a kernel run call.
*/
cl::NDRange globalThreads(width, height);
if (blockSizeX > width)
blockSizeX = width;
cl::NDRange localThreads(blockSizeX, blockSizeY);
cl::Event ndrEvt;
status = commandQueue.enqueueNDRangeKernel(
kernel,
cl::NullRange,
globalThreads,
localThreads,
0,
&ndrEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueNDRangeKernel() failed.");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = ndrEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status,
"cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
// Enqueue Read Image
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
region[0] = width;
region[1] = height;
region[2] = 1;
// Enqueue readBuffer
cl::Event readEvt;
status = commandQueue.enqueueReadImage(
outputImage2D,
CL_FALSE,
origin,
region,
0,
0,
outputImageData,
NULL,
&readEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueReadImage failed.");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = readEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status,
"cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
return 0;
}
int
GaussianNoise::runCLKernels()
{
cl_int status;
cl_int eventStatus = CL_QUEUED;
cl::Event writeEvt;
status = commandQueue.enqueueWriteBuffer(
inputImageBuffer,
CL_FALSE,
0,
width * height * pixelSize,
inputImageData,
NULL,
&writeEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueWriteBuffer() failed. (inputImageBuffer)");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = writeEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
// Set appropriate arguments to the kernel
// input buffer image
status = kernel.setArg(0, inputImageBuffer);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (inputImageBuffer)");
// outBuffer imager
status = kernel.setArg(1, outputImageBuffer);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (outputImageBuffer)");
// factor
status = kernel.setArg(2, factor);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (factor)");
/*
* Enqueue a kernel run call.
*/
// Each thread calculates 2 gaussian numbers
cl::NDRange globalThreads(width / 2, height);
cl::NDRange localThreads(blockSizeX, blockSizeY);
cl::Event ndrEvt;
status = commandQueue.enqueueNDRangeKernel(
kernel,
cl::NullRange,
globalThreads,
localThreads,
NULL,
&ndrEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueNDRangeKernel() failed.");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = ndrEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
// Enqueue readBuffer
cl::Event readEvt;
status = commandQueue.enqueueReadBuffer(
outputImageBuffer,
CL_FALSE,
0,
width * height * pixelSize,
outputImageData,
NULL,
&readEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueReadBuffer failed. (outputImageBuffer)");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = readEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
return SDK_SUCCESS;
}
int
HDRToneMapping::runCLKernels()
{
cl_int status;
cl_int eventStatus = CL_QUEUED;
if (deviceType.compare("gpu") == 0)
{
cl::Event mapEvt;
void *mapPtr = commandQueue.enqueueMapBuffer(inputImageBuffer,
CL_FALSE,
CL_MAP_WRITE,
0,
width * height * numChannels * sizeof(cl_float),
NULL,
&mapEvt,
&status);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueWriteBuffer() failed. (inputImageBuffer)");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = mapEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
memcpy(mapPtr,
input,
height * width * numChannels * sizeof(cl_float));
cl::Event unMapEvt;
status = commandQueue.enqueueUnmapMemObject(inputImageBuffer,
mapPtr,
NULL,
&unMapEvt);
CHECK_OPENCL_ERROR(status, "commandQueue.enqueueUnmapObject failed");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = unMapEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
}
// input buffer image
status = kernel.setArg(0, inputImageBuffer);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (inputImageBuffer)");
// outBuffer imager
status = kernel.setArg(1, outputImageBuffer);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (outputImageBuffer)");
// Average Luminance
status = kernel.setArg(2, averageLuminance);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (averageLuminance)");
// Gamma
status = kernel.setArg(3, gammaPattanaik);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (gammaPattanaik)");
// C
status = kernel.setArg(4, cPattanaik);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (cPattanaik)");
// Delta
status = kernel.setArg(5, deltaPattanaik);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (deltaPattanaik)");
// Width
status = kernel.setArg(6, width);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (width)");
// numChannels
status = kernel.setArg(7, numChannels);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (numChannels)");
// Height
status = kernel.setArg(8, height);
CHECK_OPENCL_ERROR(status, "Kernel::setArg() failed. (height)");
/*
* Enqueue a kernel run call.
*/
cl::NDRange globalThreads(width, height);
cl::NDRange localThreads(blockSizeX, blockSizeY);
cl::Event ndrEvt;
status = commandQueue.enqueueNDRangeKernel(
kernel,
cl::NullRange,
globalThreads,
localThreads,
NULL,
&ndrEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueNDRangeKernel() failed.");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = ndrEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
if (deviceType.compare("gpu") == 0)
{
// Enqueue readBuffer
cl::Event readEvt;
status = commandQueue.enqueueReadBuffer(
outputImageBuffer,
CL_FALSE,
0,
width * height * numChannels * sizeof(cl_float),
output,
NULL,
&readEvt);
CHECK_OPENCL_ERROR(status, "CommandQueue::enqueueReadBuffer failed. (outputImageBuffer)");
status = commandQueue.flush();
CHECK_OPENCL_ERROR(status, "cl::CommandQueue.flush failed.");
eventStatus = CL_QUEUED;
while(eventStatus != CL_COMPLETE)
{
status = readEvt.getInfo<cl_int>(
CL_EVENT_COMMAND_EXECUTION_STATUS,
&eventStatus);
CHECK_OPENCL_ERROR(status, "cl:Event.getInfo(CL_EVENT_COMMAND_EXECUTION_STATUS) failed.");
}
}
return SDK_SUCCESS;
}
