#include "OpenCLExcuter.h"
|
#include <chrono>
|
void OpenCLExcuter::init() {
|
//»ñȡƽ̨
|
error = clGetPlatformIDs(1, &platforms, &num_of_platforms);
|
if (error != 0) {
|
throw("Get platform failed!");
|
}
|
//»ñÈ¡É豸
|
error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_GPU, 1, &devices, NULL);
|
if (error != 0) {
|
throw("Get device failed!");
|
}
|
|
//´´½¨ÉÏÏÂÎÄ
|
context = clCreateContext(NULL, 1, &devices, NULL, NULL, &error);
|
if (error != 0) {
|
throw("Creat context failed!");
|
}
|
//´´½¨³ÌÐò£»×¢ÒâÒªÓÃ"rb"
|
fopen_s(&program_handle, "kernel.cl", "rb");
|
if (program_handle == NULL) {
|
throw("The kernle can not be opened!");
|
}
|
fseek(program_handle, 0, SEEK_END);
|
program_size = ftell(program_handle);
|
rewind(program_handle);
|
|
program_buffer = (char*)malloc(program_size + 1);
|
program_buffer[program_size] = '\0';
|
error = fread(program_buffer, sizeof(char), program_size, program_handle);
|
if (error == 0) {
|
throw("Read kernel failed!");
|
}
|
fclose(program_handle);
|
program = clCreateProgramWithSource(context, 1, (const char**)&program_buffer,
|
&program_size, &error);
|
if (error < 0) {
|
throw("Couldn't create the program!");
|
}
|
//±àÒë³ÌÐò
|
error = clBuildProgram(program, 1, &devices, NULL, NULL, NULL);
|
if (error < 0) {
|
//È·¶¨ÈÕÖ¾ÎļþµÄ´óС
|
clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
|
program_log = (char*)malloc(log_size + 1);
|
program_log[log_size] = '\0';
|
//¶ÁÈ¡ÈÕÖ¾
|
clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG,
|
log_size + 1, program_log, NULL);
|
printf("%s\n", program_log);
|
free(program_log);
|
throw("Build Program Failed");
|
}
|
free(program_buffer);
|
|
//´´½¨ÃüÁî¶ÓÁÐ
|
queue = clCreateCommandQueue(context, devices, CL_QUEUE_PROFILING_ENABLE, &error);
|
if (error < 0) {
|
throw("Coudn't create the command queue");
|
}
|
}
|
|
|
unsigned char** OpenCLExcuter::recognition_numbers(unsigned char* data, unsigned char* b_in, const int rows, const int cols,const int num_width, const int num_height, const int num_count) throw(std::string) {
|
//----------³ÌÐòÕýÎÄ¿ªÊ¼---------
|
auto startexectime = std::chrono::steady_clock::now();
|
const int resultSize = rows * cols / (num_width * num_height);
|
const int inputSize = rows * cols;
|
//´´½¨ÄÚºË
|
kernel = clCreateKernel(program, "recognition_numbers_1", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
//³õʼ»¯²ÎÊý
|
unsigned char* result = (unsigned char*)malloc(sizeof(unsigned char) * resultSize);
|
|
//´´½¨»º´æ¶ÔÏó
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, data, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
sizeof(unsigned char) * inputSize, b_in, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(unsigned char) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject4 failed!\n");
|
}
|
|
int width = cols / num_width;
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
|
error |= clSetKernelArg(kernel, 2, sizeof(int), &width);
|
error |= clSetKernelArg(kernel, 3, sizeof(int), &num_width);
|
error |= clSetKernelArg(kernel, 4, sizeof(int), &num_height);
|
error |= clSetKernelArg(kernel, 5, sizeof(int), &num_count);
|
error |= clSetKernelArg(kernel, 6, sizeof(cl_mem), &memObject4);
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { resultSize };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
/*
|
printf("½á¹û1£º\n");
|
for (int r = 0; r < rows / 8; r++) {
|
for (int c = 0; c < cols / 5 ; c++) {
|
printf("%d ", result[r * cols/5 + c]);
|
}
|
printf("\n-------\n");
|
}
|
*/
|
|
|
//¿ªÊ¼µÚ¶þ½×¶ÎµÄ¼ÆËã
|
int resultSize2 = resultSize / 10;
|
unsigned char* result2 = (unsigned char*)malloc(sizeof(unsigned char) * resultSize2);
|
|
kernel = clCreateKernel(program, "recognition_numbers_2", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
cl_mem memObject21 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * resultSize, result, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
cl_mem memObject22 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(unsigned char) * resultSize2, NULL, &error);
|
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject21);
|
error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject22);
|
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
size_t globalWorkSize2[1] = { resultSize2 };
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize2,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject22, CL_TRUE, 0, resultSize2 * sizeof(unsigned char),
|
result2, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
|
|
|
//ÏÔʾ½á¹û
|
/*
|
printf("½á¹û2£º\n");
|
for (int r = 0; r < rows/8; r++) {
|
for (int c = 0; c < cols/(5*10); c++) {
|
printf("%d ", result2[r*cols/(5*10)+c]);
|
}
|
printf("\n-------\n");
|
}
|
*/
|
|
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
clReleaseMemObject(memObject4);
|
clReleaseMemObject(memObject21);
|
clReleaseMemObject(memObject22);
|
|
//¸´ÖÆ×îºóµÄ¼ÆËã½á¹û
|
int fcol = num_count;
|
int frow = rows / num_height;
|
unsigned char** fresult = (unsigned char**)malloc(sizeof(unsigned char*) * frow);
|
|
for (int r = 0; r < frow; r++) {
|
fresult[r] = (unsigned char*)malloc(sizeof(unsigned char) * fcol);
|
for (int c = 0; c < fcol; c++) {
|
fresult[r][c] = result2[r * fcol + c];
|
}
|
}
|
free(result);
|
free(result2);
|
//std::cout << " Ö´ÐнáÊø£º" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - startexectime).count() << std::endl;
|
return fresult;
|
}
|
|
|
|
void OpenCLExcuter::splitL2Num(unsigned char* img, int img_width, int img_height, int* pos, int pos_count, unsigned char* zero, int num_width,int num_height,int num_count, unsigned char* result) {
|
clock_t time_0 = clock();
|
|
kernel = clCreateKernel(program, "split_num", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
int inputSize = (img_width * img_height);
|
|
int resultSize = (pos_count / 3) * (num_count * num_width * num_height * 10);
|
|
|
//´´½¨»º´æ¶ÔÏó
|
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, img, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
sizeof(int) * pos_count * 4, pos, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
cl_mem memObject3 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
sizeof(unsigned char) * num_width * num_height, zero, &error);
|
if (error < 0) {
|
throw("Creat memObject3 failed!\n");
|
}
|
|
cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(unsigned char) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject4 failed!\n");
|
}
|
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
|
error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
|
error |= clSetKernelArg(kernel, 3, sizeof(int), &img_width);
|
error |= clSetKernelArg(kernel, 4, sizeof(int), &num_width);
|
error |= clSetKernelArg(kernel, 5, sizeof(int), &num_height);
|
error |= clSetKernelArg(kernel, 6, sizeof(int), &num_count);
|
error |= clSetKernelArg(kernel, 7, sizeof(cl_mem), &memObject4);
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { pos_count };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
clReleaseMemObject(memObject3);
|
clReleaseMemObject(memObject4);
|
std::cout << " ºÄʱ£º" << (clock() - time_0) << std::endl;
|
}
|
|
|
|
void OpenCLExcuter::createNumberTemplates(int lines,int num_width,int num_height,int num_count, uchar* numsOneLevelData, unsigned char* result) {
|
kernel = clCreateKernel(program, "createTemplateNumbers", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
|
int inputSize = num_height * num_width * 10;
|
int resultSize = lines * num_count * 10 * num_height * num_width;
|
|
|
//´´½¨»º´æ¶ÔÏó
|
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, numsOneLevelData, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(unsigned char) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error |= clSetKernelArg(kernel, 1, sizeof(int), &num_width);
|
error |= clSetKernelArg(kernel, 2, sizeof(int), &num_height);
|
error |= clSetKernelArg(kernel, 3, sizeof(int), &num_count);
|
error |= clSetKernelArg(kernel, 4, sizeof(cl_mem), &memObject2);
|
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { lines };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(unsigned char),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
}
|
|
|
|
void OpenCLExcuter::splitL2RowData(unsigned char* imgs, int imgWidth, int imgHeight, int* rowIndexs, int lines,
|
int* result) {
|
|
kernel = clCreateKernel(program, "splitRowData", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
|
int inputSize = imgWidth * imgHeight;
|
int resultSize = lines * 7 * 4;
|
|
|
//´´½¨»º´æ¶ÔÏó
|
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * lines * 4, rowIndexs, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
|
cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(int) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject3 failed!\n");
|
}
|
|
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
|
error |= clSetKernelArg(kernel, 2, sizeof(int), &imgWidth);
|
error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject3);
|
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { lines };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, resultSize * sizeof(int),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
//printf("%d %d %d %d \n", result[0], result[1], result[2], result[3]);
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
clReleaseMemObject(memObject3);
|
}
|
|
void OpenCLExcuter::recognitionNotNum(unsigned char* imgs, int imgWidth, int imgHeight, int* rowIndexs,int colCount, int lines,
|
int* result) {
|
|
clock_t time_1 = clock();
|
|
|
kernel = clCreateKernel(program, "recognition_not_num", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
|
int inputSize = imgWidth * imgHeight;
|
int resultSize = lines * 2;
|
|
|
//´´½¨»º´æ¶ÔÏó
|
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * lines * 4 * colCount, rowIndexs, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
|
cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(int) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject3 failed!\n");
|
}
|
|
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
|
error |= clSetKernelArg(kernel, 2, sizeof(int), &imgWidth);
|
error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject3);
|
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { resultSize };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, resultSize * sizeof(int),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
//printf("%d %d %d %d \n", result[0], result[1], result[2], result[3]);
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
clReleaseMemObject(memObject3);
|
|
}
|
|
|
void OpenCLExcuter::rgb2Gray(unsigned char* imgs, int imgWidth, int imgHeight,
|
unsigned char* result) {
|
|
kernel = clCreateKernel(program, "rgb2GrayImg", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
|
int inputSize = imgWidth * imgHeight * 3;
|
int resultSize = imgWidth * imgHeight;
|
|
|
//´´½¨»º´æ¶ÔÏó
|
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(uchar) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error |= clSetKernelArg(kernel, 1, sizeof(int), &imgWidth);
|
error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject2);
|
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { imgHeight };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(uchar),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
|
}
|
|
|
void OpenCLExcuter::rgba2Gray(unsigned char* imgs, int imgWidth, int imgHeight,
|
unsigned char* result) {
|
|
kernel = clCreateKernel(program, "rgba2GrayImg", &error);
|
if (kernel == NULL) {
|
throw("Couldn't create kernel!\n");
|
}
|
|
|
int inputSize = imgWidth * imgHeight * 4;
|
int resultSize = imgWidth * imgHeight;
|
|
|
//´´½¨»º´æ¶ÔÏó
|
|
cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
|
if (error < 0) {
|
throw("Creat memObject1 failed!\n");
|
}
|
|
cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
sizeof(uchar) * resultSize, NULL, &error);
|
if (error < 0) {
|
throw("Creat memObject2 failed!\n");
|
}
|
|
|
//ÉèÖÃÄں˲ÎÊý
|
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
|
error |= clSetKernelArg(kernel, 1, sizeof(int), &imgWidth);
|
error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject2);
|
|
if (error != CL_SUCCESS) {
|
throw("Error setting kernel arguments!\n");
|
}
|
//Ö´ÐÐÄÚºË
|
size_t globalWorkSize[1] = { imgHeight };
|
size_t localWorkSize[1] = { 1 };
|
|
const int work_dim = 1;
|
|
error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
|
localWorkSize, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error queuing kernel for execution!\n");
|
}
|
|
//¶ÁÈ¡Ö´Ðнá¹û
|
error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(uchar),
|
result, 0, NULL, NULL);
|
if (error != CL_SUCCESS) {
|
throw("Error reading result buffer!\n");
|
}
|
|
clReleaseKernel(kernel);
|
clReleaseMemObject(memObject1);
|
clReleaseMemObject(memObject2);
|
|
}
|
|
void OpenCLExcuter::destory() {
|
//ÊÍ·Å×ÊÔ´
|
clReleaseDevice(devices);
|
clReleaseContext(context);
|
clReleaseProgram(program);
|
clReleaseCommandQueue(queue);
|
}
|
