int main(int argc, char* argv[]) {
if(argc!=3){
printf("Usage: gaussian5x5int input.pgm output.pgm\n");
return -1;
}
// pointer to the input image
unsigned char *image_in;
// pointer to the output image
unsigned char *image_out;
// image width (original width without padding)
int w;
// image height (original height without padding)
int h;
// max gray value of the PGM, usually it is 255.
int grayMax;
readPGM(&image_in, argv[1], &w, &h, &grayMax);
printf("Image File Name: %s\n",argv[1]);
printf("Image Width: %d\n",w);
printf("Image Height: %d\n",h);
image_out=(unsigned char*)malloc(w*h*sizeof(unsigned char));
gaussian5x5int((unsigned char*)image_out, (unsigned char*)image_in, w, h);
writePGM(image_out, argv[2], w, h, grayMax);
free(image_in);
free(image_out);
return 0;
}
/*
* Read an image
*/
int RImage::read(char file[100]) {
if (strstr(file, ".ppm") != NULL) {
type = PPM;
readPPM(file);
} else if (strstr(file, ".pgm") != NULL){
type = PGM;
readPGM(file);
} else if (strstr(file, ".jpeg") != NULL ||
strstr(file, ".jpg") != NULL) {
type = JPEG;
readJPEG(file);
} else if (strstr(file, ".png") != NULL) {
fprintf(stderr, "ERROR: Format not supported as yet.\n");
type = PNG;
readPNG(file);
} else {
fprintf(stderr, "ERROR: Cannot read image %s.\n", file);
exit(1);
}
return 0;
}
//!
//! @internal
//! @~English
//! @brief Read a netpbm file, either PAM, PGM or PPM
//!
//! The file type is determined from the magic number.
//! P5 is a PGM file. P6 is a PPM binary file, P7 is a PAM file.
//!
//! @param [in] src pointer to FILE stream to read
//! @param [out] width reference to variable in which to store the image width
//! @param [out] height reference to variable in which to store the image height
//! @param [out] components reference to variable in which to store the number of
//! components in an image pixel
//! @param [out] componentSize
//! reference to variable in which to store the size in bytes
//! of each component of a pixel.
//! @param [out] imageSize reference to variable in which to store the size in bytes
//! of the image.
//! @param [out] pixels reference to variable in which to store a pointer to the
//! image's pixels.
//!
//! @return an error indicator or SUCCESS
//!
//! @exception INVALID_FORMAT the file is not in .pam, .pgm or .ppm format
//!
//! @author Mark Callow
//!
FileResult
readNPBM(FILE* src, unsigned int& width, unsigned int& height,
unsigned int& components, unsigned int& componentSize,
unsigned int &imageSize, unsigned char** pixels)
{
char line[255];
int numvals;
skipNonData(src);
numvals = fscanf(src, "%3s", line);
if (numvals == 0) {
fprintf(stderr, "Error: PBM type string missing.\n");
return INVALID_FORMAT;
}
if (strcmp(line, "P6") == 0) {
return readPPM(src, width, height, components, componentSize, imageSize, pixels);
} else if (strcmp(line, "P5") == 0) {
components = 1;
return readPGM(src, width, height, components, componentSize, imageSize, pixels);
} else if (strcmp(line, "P7") == 0) {
return readPAM(src, width, height, components, componentSize, imageSize, pixels);
} else
return INVALID_FORMAT;
}
main (int argc, char *argv[]) {
int width, height, x, y, off_x, off_y;
unsigned char *data;
double maxPower;
char fname[1000];
if(argc != 2) {
fprintf(stderr, "filter : test fourier transform library.\n");
fprintf(stderr, "Usage : fourier <file name prefix>\n");
fprintf(stderr, "file : PGM monochrome\n");
exit(0);
}
// 読み出し ( 画素値型 unsigned char )
data = readPGM(argv[1], &width, &height);
printf("size = %d %d\n", width, height);
fourier(fimage, (unsigned char (*)[FFT_SIZE])data);
fourierSpectrumImage(image, fimage);
strcpy(fname, argv[1]);
strcat(fname, ".fft.pbm");
writePGM(fname, (unsigned char *)image, FFT_SIZE, FFT_SIZE);
#if 1
for( x = 0; x < FFT_SIZE; x++) {
for( y = 0; y < FFT_SIZE; y++) {
if((x > RAD && x < FFT_SIZE - RAD) || (y > RAD && y < FFT_SIZE - RAD)) {
fimage[x][y].Re = fimage[x][y].Im = 0;
}
}
}
#endif
inverseFourier(image, fimage);
strcpy(fname, argv[1]);
strcat(fname, ".filt.pbm");
writePGM(fname, (unsigned char *)image, FFT_SIZE, FFT_SIZE);
free(data);
}
int main(int argc, char *argv[])
{
//fprintf(stderr, "[%s:%d:%s()] FFT!\n", __FILE__, __LINE__, __func__);
LOG("FFT Start\n");
cl_mem xmobj = NULL;
cl_mem rmobj = NULL;
cl_mem wmobj = NULL;
cl_kernel sfac = NULL;
cl_kernel trns = NULL;
cl_kernel hpfl = NULL;
cl_uint ret_num_platforms;
cl_uint ret_num_devices;
cl_int ret;
cl_float2 *xm;
cl_float2 *rm;
cl_float2 *wm;
pgm_t ipgm;
pgm_t opgm;
FILE *fp;
const char fileName[] = "./fft.cl";
size_t source_size;
char *source_str;
cl_int i, j;
cl_int n;
cl_int m;
size_t gws[2];
size_t lws[2];
fp = fopen(fileName, "r");
if(!fp)
{
fprintf(stderr, "[%s:%d:%s()] ERROR, Failed to load kernel source.\n", __FILE__, __LINE__, __func__);
return 1;
}
source_str = (char *)malloc(MAX_SOURCE_SIZE);
source_size = fread(source_str, 1, MAX_SOURCE_SIZE, fp);
fclose(fp);
readPGM(&ipgm, "./lena.pgm");
n = ipgm.width;
m = (cl_int)(log((double)n)/log(2.0));
LOG("n = %d, m = %d.\n", m, n);
xm = (cl_float2*)malloc(n*n*sizeof(cl_float2));
rm = (cl_float2*)malloc(n*n*sizeof(cl_float2));
wm = (cl_float2*)malloc(n/2 *sizeof(cl_float2));
for( i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
{
((float*)xm)[2*(n*j + i) + 0] = (float)ipgm.buf[n*j + i];
((float*)xm)[2*(n*j + i) + 1] = (float)0;
}
}
CL_CHECK(ret = clGetPlatformIDs(MAX_PLATFORM_IDS, platform_ids, &ret_num_platforms));
platform_id = platform_ids[0];
CL_CHECK(ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, &ret_num_devices));
LOG("platform_id = %p, device_id = %p\n", platform_id, device_id);
context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret);
CL_CHECK(ret);
queue = clCreateCommandQueue(context, device_id, 0, &ret);
xmobj = clCreateBuffer(context, CL_MEM_READ_WRITE, n*n*sizeof(cl_float2), NULL, &ret);
CL_CHECK(ret);
rmobj = clCreateBuffer(context, CL_MEM_READ_WRITE, n*n*sizeof(cl_float2), NULL, &ret);
CL_CHECK(ret);
wmobj = clCreateBuffer(context, CL_MEM_READ_WRITE, n*n*sizeof(cl_float2), NULL, &ret);
CL_CHECK(ret);
CL_CHECK(ret = clEnqueueWriteBuffer(queue, xmobj, CL_TRUE, 0, n*n*sizeof(cl_float2), xm, 0, NULL, NULL));
program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret);
CL_CHECK(ret);
CL_CHECK(ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL));
sfac = clCreateKernel(program, "spinFact", &ret);
CL_CHECK(ret);
trns = clCreateKernel(program, "transpose", &ret);
CL_CHECK(ret);
hpfl = clCreateKernel(program, "highPassFilter", &ret);
CL_CHECK(ret);
CL_CHECK(ret = clSetKernelArg(sfac, 0, sizeof(cl_mem), (void *)&wmobj));
CL_CHECK(ret = clSetKernelArg(sfac, 1, sizeof(cl_int), (void *)&n));
setWorkSize(gws, lws, n/2, 1);
CL_CHECK(ret = clEnqueueNDRangeKernel(queue, sfac, 1, NULL, gws, lws, 0, NULL, NULL));
fftCore(rmobj, xmobj, wmobj, m, forward);
CL_CHECK(ret = clSetKernelArg(trns, 0, sizeof(cl_mem), (void *)&xmobj));
CL_CHECK(ret = clSetKernelArg(trns, 1, sizeof(cl_mem), (void *)&rmobj));
CL_CHECK(ret = clSetKernelArg(trns, 2, sizeof(cl_int), (void *)&n));
setWorkSize(gws, lws, n, n);
CL_CHECK(ret = clEnqueueNDRangeKernel(queue, trns, 2, NULL, gws, lws, 0, NULL, NULL));
fftCore(rmobj, xmobj, wmobj, m, forward);
#if 1 //FILTER
cl_int radius = n>>4;
CL_CHECK(ret = clSetKernelArg(hpfl, 0, sizeof(cl_mem), (void *)&rmobj));
CL_CHECK(ret = clSetKernelArg(hpfl, 1, sizeof(cl_int), (void *)&n));
CL_CHECK(ret = clSetKernelArg(hpfl, 2, sizeof(cl_int), (void *)&radius));
setWorkSize(gws, lws, n, n);
CL_CHECK(ret = clEnqueueNDRangeKernel(queue, hpfl, 2, NULL, gws, lws, 0, NULL, NULL));
#endif
#if 1 /* Inverse FFT */
fftCore(xmobj, rmobj, wmobj, m, inverse);
CL_CHECK(ret = clSetKernelArg(trns, 0, sizeof(cl_mem), (void *)&rmobj));
CL_CHECK(ret = clSetKernelArg(trns, 1, sizeof(cl_mem), (void *)&xmobj));
CL_CHECK(ret = clSetKernelArg(trns, 2, sizeof(cl_int), (void *)&n));
setWorkSize(gws, lws, n, n);
CL_CHECK(ret = clEnqueueNDRangeKernel(queue, trns, 2, NULL, gws, lws, 0, NULL, NULL));
fftCore(xmobj, rmobj, wmobj, m, inverse);
#endif
CL_CHECK(ret = clEnqueueReadBuffer(queue, xmobj, CL_TRUE, 0, n*n*sizeof(cl_float2), xm, 0, NULL, NULL));
float *ampd;
ampd = (float*)malloc(n*n*sizeof(float));
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
{
ampd[n*i + j] = AMP( ((float*)xm)[2*(n*i + j)], ((float*)xm)[2*(n*i + j) + 1] );
// fprintf(stderr, "%d ", (int)ampd[n*i + j]);
}
// fprintf(stderr, "\n");
}
opgm.width = n;
opgm.height = n;
normalizeF2PGM(&opgm, ampd);
free(ampd);
writePGM(&opgm, "output.pgm");
/* Termination */
CL_CHECK(ret = clFlush(queue));
CL_CHECK(ret = clFinish(queue));
CL_CHECK(ret = clReleaseKernel(hpfl));
CL_CHECK(ret = clReleaseKernel(trns));
CL_CHECK(ret = clReleaseKernel(sfac));
CL_CHECK(ret = clReleaseProgram(program));
CL_CHECK(ret = clReleaseMemObject(xmobj));
CL_CHECK(ret = clReleaseMemObject(rmobj));
CL_CHECK(ret = clReleaseMemObject(wmobj));
CL_CHECK(ret = clReleaseCommandQueue(queue));
CL_CHECK(ret = clReleaseContext(context));
destroyPGM(&ipgm);
destroyPGM(&opgm);
free(source_str);
free(wm);
free(rm);
free(xm);
return 0;
}
int main(int argc, char** argv)
{
cl_event event,event1,event2;
int j =0,stride=2;
int err, i =0, index =0; // error code returned from api calls
pgm_t input_pgm,output_pgm;
int ipgm_img_width,opgm_img_width;
int ipgm_img_height,opgm_img_height;
cl_device_id device_id; // compute device id
cl_context context; // compute context
cl_command_queue commands; // compute command queue
cl_program program; // compute program
cl_kernel kernel[3]; // compute kernel
// OpenCL device memory for matrices
cl_mem d_image, d_filter, d_output, d_bias;
if (argc != 2) {
printf("Expecting 2 arguments.\n");
exit(1);
}
readPGM(&input_pgm,argv[1]);
ipgm_img_width = input_pgm.width;
ipgm_img_height = input_pgm.height;
opgm_img_width = input_pgm.width;//-CONV1_FILTER_WIDTH+1;
opgm_img_height = input_pgm.height;//-CONV1_FILTER_HEIGHT+1;
printf("cl:main input image resolution:%dx%d\n", ipgm_img_width,ipgm_img_height);
printf("cl:main output image resolution:%dx%d\n", opgm_img_width,opgm_img_height);
DTYPE *h_image;
DTYPE *h_filter, *h_bias, *h_output;
// Allocate host memory for matrices
unsigned int size_image = ipgm_img_width*ipgm_img_height;
unsigned int mem_size_image = sizeof(DTYPE) * size_image;
h_image = (DTYPE*)malloc(mem_size_image);
for(i=0;i<size_image;i++)
{
h_image[i] = (DTYPE) input_pgm.buf[i]/255;
}
unsigned int size_filter = CONV1_FILTER_WIDTH*CONV1_FILTER_HEIGHT;
unsigned int mem_size_filter = sizeof(DTYPE) * size_filter;
h_filter = (DTYPE*) conv1_weights;
unsigned int size_output = opgm_img_width * opgm_img_height;
unsigned int mem_size_output = sizeof(DTYPE) * size_output;
h_output = (DTYPE*) malloc(mem_size_output);
unsigned int size_bias = 1; //1 bias value for 1 output map
unsigned int mem_size_bias = sizeof(DTYPE) * size_bias;
h_bias = (DTYPE*) conv1_bias;
cl_uint dev_cnt = 0;
clGetPlatformIDs(0, 0, &dev_cnt);
cl_platform_id platform_ids[5];
clGetPlatformIDs(dev_cnt, platform_ids, NULL);
for(i=0;i<dev_cnt;i++)
{
#ifdef DEVICE_GPU
err = clGetDeviceIDs(platform_ids[i], CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
#else
err = clGetDeviceIDs(platform_ids[i], CL_DEVICE_TYPE_CPU, 1, &device_id, NULL);
#endif
if(err == CL_SUCCESS)
break;
}
if (err != CL_SUCCESS)
{
if(err == CL_INVALID_PLATFORM)
printf("CL_INVALID_PLATFORM\n");
if(err == CL_INVALID_DEVICE_TYPE)
printf("CL_INVALID_DEVICE_TYPE\n");
if(err == CL_INVALID_VALUE)
printf("CL_INVALID_VALUE\n");
if(err == CL_DEVICE_NOT_FOUND)
printf("CL_DEVICE_NOT_FOUND\n");
printf("Error: Failed to create a device group!\n");
return EXIT_FAILURE;
}
// Create a compute context
context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
if (!context)
{
printf("Error: Failed to create a compute context!\n");
return EXIT_FAILURE;
}
// Create a command commands
commands = clCreateCommandQueue(context, device_id, CL_QUEUE_PROFILING_ENABLE, &err);
if (!commands)
{
printf("Error: Failed to create a command commands!\n");
return EXIT_FAILURE;
}
// Create the compute program from the source file
char *KernelSource;
long lFileSize;
lFileSize = LoadOpenCLKernel("kernels.cl", &KernelSource);
if( lFileSize < 0L ) {
perror("File read failed");
return 1;
}
program = clCreateProgramWithSource(context, 1, (const char **) & KernelSource, NULL, &err);
if (!program)
{
printf("Error: Failed to create compute program!\n");
return EXIT_FAILURE;
}
// Build the program executable
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS)
{
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
exit(1);
}
kernel[0] = clCreateKernel(program, "conv_2d", &err);
if (!kernel[0] || err != CL_SUCCESS)
{
printf("Error: Failed to create compute kernel!\n");
exit(1);
}
d_image = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR /*| CL_MEM_USE_MSMC_TI*/, mem_size_image, h_image, &err);
cl_ulong time_start, time_end;
double total_time;
// Create the input and output arrays in device memory for our calculation
d_filter = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR /*| CL_MEM_USE_MSMC_TI*/, mem_size_filter, h_filter, &err);
d_output = clCreateBuffer(context, CL_MEM_WRITE_ONLY /*| CL_MEM_USE_MSMC_TI*/, mem_size_output, NULL, &err);
d_bias = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR , mem_size_bias, h_bias, &err);
if (!d_image || !d_filter || !d_output || !d_bias)
{
printf("Error: Failed to allocate device memory!\n");
exit(1);
}
// Launch OpenCL kernel
size_t localWorkSize[2], globalWorkSize[2];
int filter_width = CONV1_FILTER_WIDTH;
int filter_height = CONV1_FILTER_HEIGHT;
localWorkSize[0] = opgm_img_width;
localWorkSize[1] = opgm_img_height/NUM_WORK_GROUPS;
globalWorkSize[0] = opgm_img_width;
globalWorkSize[1] = opgm_img_height;
err = clSetKernelArg(kernel[0], 0, sizeof(cl_mem), (void *)&d_image);
err |= clSetKernelArg(kernel[0], 1, sizeof(cl_mem), (void *)&d_filter);
err |= clSetKernelArg(kernel[0], 2, sizeof(cl_mem), (void *)&d_output);
err |= clSetKernelArg(kernel[0], 3, sizeof(int), (void *)&filter_width);
err |= clSetKernelArg(kernel[0], 4, sizeof(int), (void *)&filter_height);
err |= clSetKernelArg(kernel[0], 5, sizeof(cl_mem), (void*)&d_bias);
err |= clSetKernelArg(kernel[0], 6, sizeof(float)*localWorkSize[0]*(localWorkSize[1]+filter_height-1), (void*)NULL);
if (err != CL_SUCCESS) {
printf("Error: Failed to set kernel arguments! %d\n", err);
exit(1);
}
/*Enqueue task for parallel execution*/
err = clEnqueueNDRangeKernel(commands, kernel[0], 2, NULL, globalWorkSize, localWorkSize, 0, NULL, &event);
if (err != CL_SUCCESS)
{
if(err == CL_INVALID_WORK_ITEM_SIZE)
printf("CL_INVALID_WORK_ITEM_SIZE \n");
if(err == CL_INVALID_WORK_GROUP_SIZE)
printf("CL_INVALID_WORK_GROUP_SIZE \n");
printf("Error: Failed to execute kernel! %d\n", err);
exit(1);
}
clWaitForEvents(1,&event);
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL);
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL);
total_time = (double)(time_end - time_start);
// Retrieve result from device
err = clEnqueueReadBuffer(commands, d_output, CL_TRUE, 0, mem_size_output, h_output, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to read output array! %d\n", err);
exit(1);
}
clReleaseMemObject(d_filter);
clReleaseMemObject(d_output);
clReleaseMemObject(d_bias);
char fileoutputname[15];
output_pgm.width = opgm_img_width;
output_pgm.height = opgm_img_height;
normalizeF2PGM(&output_pgm, h_output);
sprintf(fileoutputname, "output2d.pgm");
/* Output image */
writePGM(&output_pgm,fileoutputname);
printf("cl:main timing %0.3f us\n", total_time / 1000.0);
destroyPGM(&input_pgm);
destroyPGM(&output_pgm);
free(h_image);
free(h_output);
clReleaseMemObject(d_image);
clReleaseProgram(program);
clReleaseKernel(kernel[0]);
clReleaseCommandQueue(commands);
clReleaseContext(context);
return 0;
}
int main(int argc, char** argv)
{
int err; // error code returned from api calls
int test_fail = 0;
pgm_t input_img, output_img;
IMG_DTYPE filter[FILTER_SIZE*FILTER_SIZE] = {-1, -1, -1, -1, 8, -1, -1, -1, -1};
IMG_DTYPE *h_input; // input image buffer
IMG_DTYPE *hw_output; // host buffer for device output
IMG_DTYPE *sw_output; // host buffer for reference output
size_t global[2]; // global domain size for our calculation
size_t local[2]; // local domain size for our calculation
cl_platform_id platform_id; // platform id
cl_device_id device_id; // compute device id
cl_context context; // compute context
cl_command_queue commands; // compute command queue
cl_program program; // compute program
cl_kernel kernel; // compute kernel
char cl_platform_vendor[1001];
char cl_platform_name[1001];
cl_mem d_in_image; // device buffer for input image
cl_mem d_in_filter; // device buffer for filter kernel
cl_mem d_out_image; // device buffer for filtered image
printf("Application start\n");
if (argc != 3) {
printf("Usage: %s conv_2d.xclbin image_path/image_name.pgm\n", argv[0]);
return EXIT_FAILURE;
}
int row, col, pix;
// read the image and initialize the host buffer with that
err = readPGM(&input_img, argv[2]);
if(err < 0) {
printf("Cound not read the image\n");
return EXIT_FAILURE;
}
printf("Input image resolution = %xx%d\n", input_img.width, input_img.height);
h_input = (IMG_DTYPE*)malloc(sizeof(IMG_DTYPE)*input_img.height*input_img.width);
hw_output = (IMG_DTYPE*)malloc(sizeof(IMG_DTYPE)*input_img.height*input_img.width);
sw_output = (IMG_DTYPE*)malloc(sizeof(IMG_DTYPE)*input_img.height*input_img.width);
for(pix = 0; pix < input_img.height*input_img.width; pix++) {
h_input[pix] = input_img.buf[pix];
}
// Connect to first platform
//
err = clGetPlatformIDs(1,&platform_id,NULL);
if (err != CL_SUCCESS) {
printf("Error: Failed to find an OpenCL platform!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
err = clGetPlatformInfo(platform_id,CL_PLATFORM_VENDOR,1000,(void *)cl_platform_vendor,NULL);
if (err != CL_SUCCESS) {
printf("Error: clGetPlatformInfo(CL_PLATFORM_VENDOR) failed!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
printf("INFO: CL_PLATFORM_VENDOR %s\n",cl_platform_vendor);
err = clGetPlatformInfo(platform_id,CL_PLATFORM_NAME,1000,(void *)cl_platform_name,NULL);
if (err != CL_SUCCESS) {
printf("Error: clGetPlatformInfo(CL_PLATFORM_NAME) failed!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
printf("INFO: CL_PLATFORM_NAME %s\n",cl_platform_name);
// Connect to a compute device
//
err = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_ACCELERATOR,
1, &device_id, NULL);
if (err != CL_SUCCESS) {
printf("Error: Failed to create a device group!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
// Create a compute context
//
context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
if (!context) {
printf("Error: Failed to create a compute context!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
// Create a command commands
//
commands = clCreateCommandQueue(context, device_id, 0, &err);
if (!commands) {
printf("Error: Failed to create a command commands!\n");
printf("Error: code %i\n",err);
printf("Test failed\n");
return EXIT_FAILURE;
}
int status;
// Create Program Objects
//
// Load binary from disk
unsigned char *kernelbinary;
char *xclbin = argv[1];
printf("INFO: loading xclbin %s\n", xclbin);
int n_i = load_file_to_memory(xclbin, (char **) &kernelbinary);
if (n_i < 0) {
printf("failed to load kernel from xclbin0: %s\n", xclbin);
printf("Test failed\n");
return EXIT_FAILURE;
}
size_t n = n_i;
// Create the compute program from offline
program = clCreateProgramWithBinary(context, 1, &device_id, &n,
(const unsigned char **) &kernelbinary, &status, &err);
if ((!program) || (err!=CL_SUCCESS)) {
printf("Error: Failed to create compute program0 from binary %d!\n", err);
printf("Test failed\n");
return EXIT_FAILURE;
}
// Build the program executable
//
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS) {
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
printf("Test failed\n");
return EXIT_FAILURE;
}
// Create the compute kernel in the program we wish to run
//
kernel = clCreateKernel(program, "conv_2d", &err);
if (!kernel || err != CL_SUCCESS) {
printf("Error: Failed to create compute kernel!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
// Create the input and output arrays in device memory for our calculation
//
d_in_image = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(IMG_DTYPE) * input_img.height*input_img.width, NULL, NULL);
d_in_filter = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(IMG_DTYPE) * FILTER_SIZE * FILTER_SIZE, NULL, NULL);
d_out_image = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(IMG_DTYPE) * input_img.height*input_img.width, NULL, NULL);
if (!d_in_image || !d_in_filter || !d_out_image) {
printf("Error: Failed to allocate device memory!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
// Write the image from host buffer to device memory
//
err = clEnqueueWriteBuffer(commands, d_in_image, CL_TRUE, 0, sizeof(IMG_DTYPE) * input_img.height*input_img.width, h_input, 0, NULL, NULL);
if (err != CL_SUCCESS) {
printf("Error: Failed to write to image to device memory!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
// Write filter kernel into device buffer
//
err = clEnqueueWriteBuffer(commands, d_in_filter, CL_TRUE, 0, sizeof(IMG_DTYPE) * FILTER_SIZE * FILTER_SIZE, filter, 0, NULL, NULL);
if (err != CL_SUCCESS) {
printf("Error: Failed to write to filter coeff into device memory!\n");
printf("Test failed\n");
return EXIT_FAILURE;
}
// Set the arguments to our compute kernel
//
int filter_size = FILTER_SIZE;
IMG_DTYPE bias = 1;
err = 0;
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_in_image);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_in_filter);
err |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &d_out_image);
//err |= clSetKernelArg(kernel, 3, sizeof(int), &filter_size);
err |= clSetKernelArg(kernel, 3, sizeof(IMG_DTYPE), &bias);
if (err != CL_SUCCESS) {
printf("Error: Failed to set kernel arguments! %d\n", err);
printf("Test failed\n");
return EXIT_FAILURE;
}
// Launch computation kernel
global[0] = input_img.width * WORKGROUP_SIZE_0;
global[1] = input_img.height * WORKGROUP_SIZE_1;
local[0] = WORKGROUP_SIZE_0;
local[1] = WORKGROUP_SIZE_1;
err = clEnqueueNDRangeKernel(commands, kernel, 2, NULL,
(size_t*)&global, (size_t*)&local, 0, NULL, NULL);
if (err) {
printf("Error: Failed to execute kernel! %d\n", err);
printf("Test failed\n");
return EXIT_FAILURE;
}
// Read back the results from the device to verify the output
//
cl_event readevent;
err = clEnqueueReadBuffer( commands, d_out_image, CL_TRUE, 0, sizeof(IMG_DTYPE) * input_img.width*input_img.height, hw_output, 0, NULL, &readevent
);
if (err != CL_SUCCESS) {
printf("Error: Failed to read output array! %d\n", err);
printf("Test failed\n");
return EXIT_FAILURE;
}
clWaitForEvents(1, &readevent);
// Generate reference output
int kr, kc;
IMG_DTYPE sum = 0;
for(row = 0; row < input_img.height-FILTER_SIZE+1; row++) {
for(col = 0; col < input_img.width-FILTER_SIZE+1; col++) {
sum = 0;
for(kr = 0; kr < FILTER_SIZE; kr++) {
for(kc = 0; kc < FILTER_SIZE; kc++ ) {
sum += (filter[kr*FILTER_SIZE + kc] * h_input[(row+kr)*input_img.width + col + kc]);
}
}
sw_output[row*input_img.width + col] = sum + bias;
}
}
// Check Results
for(row = 0; row < input_img.height-FILTER_SIZE+1; row++) {
for(col = 0; col < input_img.width-FILTER_SIZE+1; col++) {
if(sw_output[row*input_img.width+col] != hw_output[row*input_img.width+col]){
printf("Mismatch at : row = %d, col = %d, expected = %f, got = %f\n",
row, col, sw_output[row*input_img.width+col], hw_output[row*input_img.width+col]);
test_fail = 1;
}
}
}
printf("---------Input image-----------\n");
//print_matrix(h_input, input_img.height, input_img.width);
printf("---------Reference output------\n");
//print_matrix(sw_output, input_img.height, input_img.width);
printf("---------OCL Kernel output-----\n");
//print_matrix(hw_output, input_img.height, input_img.width);
// store the output image
output_img.width = input_img.width;
output_img.height = input_img.height;
normalizeF2PGM(&output_img, hw_output);
writePGM(&output_img, "../../../../fpga_output.pgm");
//--------------------------------------------------------------------------
// Shutdown and cleanup
//--------------------------------------------------------------------------
clReleaseMemObject(d_in_image);
clReleaseMemObject(d_in_filter);
clReleaseMemObject(d_out_image);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(commands);
clReleaseContext(context);
destroyPGM(&input_img);
if (test_fail) {
printf("INFO: Test failed\n");
return EXIT_FAILURE;
} else {
printf("INFO: Test passed\n");
}
}
/*Main program*/
void main()
{
char filename[100],ch,ans;
int selection,width,height;
const char * source_fileName;
const char * modified_fileName = "output.pgm";
const char * inte_fileName = "intermediate.pgm";
printf("\n************WELCOME***************");
printf("\nEnter image file to read(pgm format) : ");
scanf("%s",&filename);
source_fileName=filename;
printf("Reading image \"%s\" ...\n", source_fileName);
do
{
orig = readPGM(source_fileName, orig);
printf("\nDo you want to Enter Window size for the image?(Y/N)");
printf("\nEnter your ans here:");
getchar();
scanf("%c",&ans);
if(ans == 'y' || ans =='Y')
{
printf("\nEnter width < %d of window here:",orig->row);
scanf("%d",&width);
printf("\nEnter height < %d of window here:",orig->col);
scanf("%d",&height);
imgdata=&ImageData;
imgdata->row=width;
imgdata->col=height;
imgdata->max_gray=orig->max_gray;
imgdata->matrix = allocate_dynamic_matrix(imgdata->row,imgdata->col);
for(int m=0;m<width;m++)
for(int n=0;n<height;n++)
{
imgdata->matrix[m][n]=orig->matrix[m][n];
}
}
else
imgdata = orig;
printf("\n*********Image Scaling Options*************");
printf("\n\t1.Nearest Neighbour Method");
printf("\n\t2.Bilinear Interpolation");
printf("\nEnter your selection here:");
scanf("%d",&selection);
switch (selection)
{
case 1: near(orig);
break;
case 2: bipol(orig);
break;
default: printf("Invaild choice\n Exiting program...");
exit(1);
break;
}
writePGM(modified_fileName,newj);
writePGM(inte_fileName,imgdata);
printf("\nFile Writing complete");
printf("\nopening outputfile......");
/***** open a output file in openseeit ****/
char program[100] = "OpenSeeIt.exe ";
char *openme;
openme= strcat(program,modified_fileName);
system(openme);
printf("\nDo you want to continue?(Y/N)\nEnter your answer here:");
getchar();
ch=getchar();
}while(ch=='Y' || ch=='y');
}
int main(int argc, char *argv[])
{
nttw_integer *image, *frtSpace, *perpFlags, type, addNoise = FALSE;
nttw_big_integer *finiteAngles, totalAngles = 0;
vector *angles;
long *result;
size_t n, N, size, Q, P, binaryFile = FALSE;
unsigned long long durationAngle = 0, durationTransform = 0;
printf(">| Fast Mojette Program.\n");
printf(">| Copyright Shekhar Chandra, 2008-10\n");
printf(">| Machine Integer Size of %u bits\n",BITS);
#if defined (NTTW_64)
printf(">| Using 64-bit mode.\n");
#else
printf(">| Using 32-bit mode.\n");
#endif
if(argc != 6)
{
printf(">| Usage: %s <filename> <N> <Angle Type> <Noise?> <output>\n",argv[0]);
printf(">| filename is loaded and transformed to produce output.\n");
printf(">| N is the size of the FFT space to be used.\n");
printf(">| Angle Type is an integer 0-2 where 1 - l1, 2 - Simple.\n");
printf(">| Noise is a Boolean and output is the FRT space.\n");
printf(">| Files should be PGM formats.\n");
return EXIT_FAILURE;
}
N = atoi(argv[2]);
type = atoi(argv[3]);
addNoise = atoi(argv[4]);
size = N+N/2;
//--------------------------------------------
///Load Image
if(!readPGM(&image,&Q,&P,argv[1],binaryFile))
{
fprintf(stderr,">| Error Opening File: %s\n",argv[1]);
return EXIT_FAILURE;
}
if(P > Q)
n = P;
else
n = Q;
perpFlags = array_1D(size);
finiteAngles = array_1D_big(size);
angles = vectorArray_2D(size);
result = arraySigned_1D(N*N);
init_1D(perpFlags,size,FALSE);
//--------------------------------------------
///Fast FRT
fprintf(stderr,">| Creating Angle Set... ");
START_TIMER;
if(type == 0)
{
///Fast FRT Angles
fprintf(stderr,"via a possible L1 set... ");
totalAngles = fmt_angleSet(N, n, n, angles, finiteAngles, perpFlags);
}
else if(type == 2)
{
///Use simple Farey set for Finite Set
///Fast FRT Angles
fprintf(stderr,"via the simple set... ");
totalAngles = fmt_angleSet_Simple(N, angles, finiteAngles, perpFlags);
}
else
{
///Force L1 while creating Finite Set
///Fast FRT Angles
fprintf(stderr,"via the L1 set... ");
totalAngles = fmt_angleSet_L1(N, n, n, angles, finiteAngles, perpFlags);
}
STOP_TIMER;
durationAngle = MICROSECONDS_ELAPSED;
fprintf(stderr,"Done. Time: %llu usecs.\n", durationAngle);
printf(">| Acquired %lu of %lu angles.\n", size, totalAngles);
//--------------------------------------------
///Output Result to Std if small (N < 64)
if(N < 64)
{
printf(">| Selected: \n");
for(n = 0; n < size; n ++)
printf("%li/%li, ",getY(angles[n]),getX(angles[n]));
printf("\n");
printf(">| Finite Angles: \n");
for(n = 0; n < size; n ++)
printf(FORMAT_BIG_CSVOUTPUT_STR,finiteAngles[n]);
printf("\n");
printf(">| Perp Flags: \n");
for(n = 0; n < size; n ++)
printf(FORMAT_CSVOUTPUT_STR,perpFlags[n]);
printf("\n");
}
//--------------------------------------------
fprintf(stderr,">| Transforming... ");
START_TIMER;
if(addNoise)
frtSpace = fmt_noise(P, Q, image, angles, finiteAngles, perpFlags, N, SNR);
else
frtSpace = fmt(P, Q, image, angles, finiteAngles, perpFlags, N);
STOP_TIMER;
durationTransform = MICROSECONDS_ELAPSED;
fprintf(stderr,"Done. Time: %llu usecs.\n", durationTransform);
fprintf(stderr,">| Total Time: %llu usecs.\n", durationAngle+durationTransform);
///TEST RESULT - iFRT
fprintf(stderr,">| TEST: Computing Inversion... \n");
START_TIMER;
ifrt_dyadic_signed(frtSpace,result,N,TRUE);
STOP_TIMER;
durationTransform = MICROSECONDS_ELAPSED;
fprintf(stderr,">| Done. Took %llu usecs.\n",durationTransform);
///Write result
writePGM(frtSpace,size,N,255,argv[5],binaryFile);
writeSignedPGM(result,N,N,255,"fmt_result.pgm",binaryFile);
fprintf(stderr,">| Test Inversion output to fmt_result.pgm.\n");
//--------------------------------------------
///Cleanup
printf(">| Operation Complete\n");
free_array(image);
free_array(perpFlags);
free_array(finiteAngles);
free_vectorArray(angles,size);
free_array(frtSpace);
free_array(result);
return EXIT_SUCCESS;
}
int main()
{
long long timer1 = 0;
long long timer2 = 0;
register int i,j;
float *in_image;
float *out_image;
int width, height;
pgm_t ipgm;
pgm_t opgm;
/* Image file input */
readPGM(&ipgm, "lena.pgm");
printf("c:main program:log read_done\n");
width = ipgm.width;
height = ipgm.height;
printf("c:main program:log img_width %d\n",width);
printf("c:main program:log img_height %d\n", height);
in_image = (float *)malloc(width * height * sizeof(float));
out_image = (float *)malloc(width * height * sizeof(float));
for( i = 0; i < width; i++ ) {
for( j = 0; j < height; j++ ) {
((float*)in_image)[(width*j) + i] = (float)ipgm.buf[width*j + i];
}
}
timer1 = PAPI_get_virt_usec();
for( i = 0; i < width; i++ ) {
for( j = 0; j < height; j++ ) {
((float*)out_image)[(height*i) + j] = ((float*)in_image)[(width*j) + i];
}
}
timer2 = PAPI_get_virt_usec();
printf("c:main timing:PAPI logic %llu us\n",(timer2-timer1));
printf("c:main program:log compute_done\n");
opgm.width = height ;
opgm.height = width ;
normalizeF2PGM(&opgm, out_image);
/* Image file output */
writePGM(&opgm, "output.pgm");
printf("c:main program:log output_done\n");
destroyPGM(&ipgm);
destroyPGM(&opgm);
free(in_image);
free(out_image);
return 0;
}
/**
* Lee y genera las texturas utilizadas
*/
void genTexturas() {
paleta = loadPalInt("paletas/landcolor3.ppm", 256);
paletaf = intPal2Float(paleta, 256);
paleta_agua = loadPalInt("paletas/watercolor7.ppm", 256);
paleta_aguaf = intPal2Float(paleta_agua, 256);
paleta_grass = loadPalInt("paletas/grasscolor2.ppm", 256);
paleta_grassf = intPal2Float(paleta_grass, 256);
tree = readPPM("paletas/tree.ppm");
snowtree = readPPM("paletas/treesnow.ppm");
treealpha = readPGM("paletas/treealpha.pgm");
datatree = genTextIntAlpha(tree, treealpha, 256);
datasnowtree = genTextIntAlpha(snowtree, treealpha, 256);
paletanubes = loadPalInt("paletas/skyalpha.ppm", 256);
nubesalpha = skyalpha3D(paletanubes, FRAMES_NUBES, int((nubosidad)*128.0), 256);
nubes = new rgbint*[256]; // nubes blancas
for (int i=0; i<256; i++){
nubes[i] = new rgbint[256];
for (int j=0; j<256; j++){
nubes[i][j].r = 255;
nubes[i][j].g = 255;
nubes[i][j].b = 255;
}
}
datanubes = new int*[FRAMES_NUBES];
for (int i=0; i<FRAMES_NUBES; i++){
datanubes[i] = genTextIntAlpha(nubes,nubesalpha[i],256);
}
//writePGMint("../../nubes3D.pgm", nubesalpha[0], 256);
// Genera los nombres de textura
glGenTextures(15, texNames);
glBindTexture(GL_TEXTURE_2D, texNames[ARBOL]);
genText(datatree, false, 256);
glBindTexture(GL_TEXTURE_2D, texNames[ARBOLNIEVE]);
genText(datasnowtree,false, 256);
for (int i=0; i<FRAMES_NUBES; i++){
glBindTexture(GL_TEXTURE_2D, texNames[NUBES+i]);
genText(datanubes[i], true, 256);
}
brujula = new rgbint*[128]; // brujula negra
for (int i=0; i<128; i++){
brujula[i] = new rgbint[128];
for (int j=0; j<128; j++){
brujula[i][j].r = 0;
brujula[i][j].g = 0;
brujula[i][j].b = 0;
}
}
brujulaalpha = readPGM("paletas/brujulaalpha.pgm");
databrujula = genTextIntAlpha(brujula, brujulaalpha, 128);
aguja = readPPM("paletas/aguja.ppm");
agujaalpha = readPGM("paletas/agujaalpha.pgm");
dataaguja = genTextIntAlpha(aguja, agujaalpha, 128);
glBindTexture(GL_TEXTURE_2D, texNames[BRUJULA]);
genText(databrujula,false, 128);
glBindTexture(GL_TEXTURE_2D, texNames[AGUJA]);
genText(dataaguja,false, 128);
}
int main(int argc, char** argv)
{
cl_event event;
int err, i = 0; // error code returned from api calls
cl_ulong time_start, time_end;
double total_time = 0;
pgm_t input_pgm, output_pgm;
cl_device_id device_id; // compute device id
cl_context context; // compute context
cl_command_queue commands; // compute command queue
cl_program program; // compute program
cl_kernel kernel; // compute kernel
// OpenCL device memory for matrices
cl_mem d_image, d_filter, d_output;
// Simple laplacian kernel
DTYPE lap_filter[FILTER_SIZE*FILTER_SIZE] = {-1.0, -1.0, -1.0, -1.0, 8.0, -1.0, -1.0, -1.0, -1.0};
DTYPE bias = 0.01;
if (argc != 2) {
printf("Usage: %s <image_name.pgm>\n", argv[0]);
exit(1);
}
// Read the input image
readPGM(&input_pgm, argv[1]);
printf("Host: Input image resolution:%dx%d\n", input_pgm.width, input_pgm.height);
DTYPE *h_image, *h_image_padded;
DTYPE *h_filter, *h_output, *ref_output;
// Allocate host memory for images and outputs
h_image = (DTYPE*)malloc(sizeof(DTYPE)*input_pgm.width*input_pgm.height);
ref_output = (DTYPE*)malloc(sizeof(DTYPE)*input_pgm.width*input_pgm.height);
//setup padded input image
const int PADDED_SIZE = sizeof(DTYPE)*(input_pgm.width+FILTER_SIZE-1)*(input_pgm.height+FILTER_SIZE-1);
h_image_padded = (DTYPE*)malloc(PADDED_SIZE);
memset((void*)h_image_padded, 0, PADDED_SIZE); //init padded image to 0s
int offset = 0; //Used for padded image
// Convert range from [0, 255] to [0.0, 1.0]
for(i = 0; i < input_pgm.width * input_pgm.height; i++)
{
if(i%input_pgm.width == 0 && i>0){ //if end of image row
offset += FILTER_SIZE-1; //bump padded image to next row
}
h_image[i] = (DTYPE) input_pgm.buf[i]/255.0;
h_image_padded[i+offset] = h_image[i];
}
h_filter = (DTYPE*) lap_filter;
h_output = (DTYPE*) malloc(sizeof(DTYPE)*input_pgm.width*input_pgm.height);
// Platform and device query
cl_uint dev_cnt = 0;
clGetPlatformIDs(0, 0, &dev_cnt);
cl_platform_id platform_ids[5];
clGetPlatformIDs(dev_cnt, platform_ids, NULL);
for(i = 0;i < dev_cnt; i++)
{
err = clGetDeviceIDs(platform_ids[i], CL_DEVICE_TYPE_CPU, 1, &device_id, NULL);
if(err == CL_SUCCESS)
break;
}
if (err != CL_SUCCESS)
{
printf("Error: Failed to create a device group!\n");
return EXIT_FAILURE;
}
// Create a compute context
context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
if (!context)
{
printf("Error: Failed to create a compute context!\n");
return EXIT_FAILURE;
}
// Create a command commands
commands = clCreateCommandQueue(context, device_id, CL_QUEUE_PROFILING_ENABLE, &err);
if (!commands)
{
printf("Error: Failed to create a command commands!\n");
return EXIT_FAILURE;
}
// Create the compute program from the source file
char *KernelSource;
long lFileSize;
lFileSize = LoadOpenCLKernel("conv_kernel.cl", &KernelSource);
if( lFileSize < 0L ) {
perror("File read failed");
return 1;
}
program = clCreateProgramWithSource(context, 1, (const char **) & KernelSource, NULL, &err);
if (!program)
{
printf("Error: Failed to create compute program!\n");
return EXIT_FAILURE;
}
// Build the program executable
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS)
{
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
exit(1);
}
kernel = clCreateKernel(program, "conv_2d", &err);
if (!kernel || err != CL_SUCCESS)
{
printf("Error: Failed to create compute kernel!\n");
exit(1);
}
// Allocate the device buffer for input image, kernel and transfer the data
d_image = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, PADDED_SIZE, h_image_padded, &err);
// Create the input and output arrays in device memory for our calculation
d_filter = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(DTYPE)*FILTER_SIZE*FILTER_SIZE, h_filter, &err);
d_output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(DTYPE)*input_pgm.width*input_pgm.height, NULL, &err);
if (!d_image || !d_filter || !d_output)
{
printf("Error: Failed to allocate device memory!\n");
exit(1);
}
size_t localWorkSize[2], globalWorkSize[2];
int filter_size = FILTER_SIZE;
// Setup the kernel arguments
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_image);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_filter);
err |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &d_output);
err |= clSetKernelArg(kernel, 3, sizeof(int), &filter_size);
err |= clSetKernelArg(kernel, 4, sizeof(DTYPE), &bias);
if (err != CL_SUCCESS) {
printf("Error: Failed to set kernel arguments! %d\n", err);
exit(1);
}
globalWorkSize[0] = input_pgm.width;
globalWorkSize[1] = input_pgm.height;
localWorkSize[0] = 1;
localWorkSize[1] = 1;
uint trials = 1;
printf("Launching the kernel...\n");
for(uint j=0; j<trials;j++){
/*Enqueue task for parallel execution*/
err = clEnqueueNDRangeKernel(commands, kernel, 2, NULL, globalWorkSize, localWorkSize, 0, NULL, &event);
if (err != CL_SUCCESS)
{
printf("Error: Failed to execute kernel! %d\n", err);
exit(1);
}
// Wait for the commands to finish
clWaitForEvents(1, &event);
// Get the profiling info
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL);
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL);
total_time += (double)(time_end - time_start);
}
total_time /= trials;
// Retrieve result from device
printf("Reading output buffer into host memory...\n");
err = clEnqueueReadBuffer(commands, d_output, CL_TRUE, 0, sizeof(DTYPE)*input_pgm.width*input_pgm.height, h_output, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to read output array! %d\n", err);
exit(1);
}
//-------------------------------------------------------------
// Compare between host and device output
// Generate reference output
int kr, kc, row, col;
DTYPE sum = 0;
for(row = 0; row < input_pgm.height; row++) {
for(col = 0; col < input_pgm.width; col++) {
sum = 0;
for(kr = 0; kr < FILTER_SIZE; kr++) {
for(kc = 0; kc < FILTER_SIZE; kc++ ) {
sum += (lap_filter[kr*FILTER_SIZE + kc] * h_image_padded[(row+kr)*(input_pgm.width+FILTER_SIZE-1) + col + kc]);
}
}
ref_output[row*input_pgm.width + col] = sum + bias;
}
}
// Check Results
int test_fail = 0;
for(row = 0; row < input_pgm.height; row++) {
for(col = 0; col < input_pgm.width; col++) {
if(ref_output[row*input_pgm.width+col] != h_output[row*input_pgm.width+col]){
printf("Mismatch at : row = %d, col = %d, expected = %f, got = %f\n",
row, col, ref_output[row*input_pgm.width+col], h_output[row*input_pgm.width+col]);
test_fail = 1;
}
}
}
output_pgm.width = input_pgm.width;
output_pgm.height = input_pgm.height;
// Remove garbage pixels in the border. If not, this will effect the subsequent normalization.!
for(row = 0; row < output_pgm.height; row++) {
for(col = 0; col < output_pgm.width; col++) {
if(row > output_pgm.height- FILTER_SIZE || col > output_pgm.width-FILTER_SIZE)
h_output[row * output_pgm.width + col] = 0.0;
}
}
normalizeF2PGM(&output_pgm, h_output);
/* Output image */
writePGM(&output_pgm, "ocl_output.pgm");
if (test_fail) {
printf("INFO: TEST FAILED !!!!\n");
} else {
printf("INFO: ****TEST PASSED****\n");
}
printf("Kernel runtime = %0.3f us\n", total_time / 1000.0);
destroyPGM(&input_pgm);
destroyPGM(&output_pgm);
free(h_image);
free(h_image_padded);
free(h_output);
free(ref_output);
clReleaseMemObject(d_image);
clReleaseMemObject(d_filter);
clReleaseMemObject(d_output);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(commands);
clReleaseContext(context);
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
//----------------
hLog = fopen("log.txt", "w");
LPCTSTR path = L".\\options.ini";
TCHAR stecilPicturePathResult[4096];
TCHAR maskedPicturePathResult[4096];
TCHAR serverPortResult[255];
TCHAR serverIPResult[255];
TCHAR listenUDPPortResult[255];
TCHAR listenUDPIPResult[255];
TCHAR colorResult[255];
TCHAR shiftXResult[255];
TCHAR shiftYResult[255];
TCHAR isEyeWindowShowResult[255];
TCHAR isEyePositionWindowShowResult[255];
TCHAR isCalibrateResult[255];
char buffer[4096];
GetPrivateProfileString(_T("Base"), _T("stecilPicturePath"), _T(""), stecilPicturePathResult, sizeof(buffer), path);
GetPrivateProfileString(_T("Base"), _T("maskedPicturePath"), _T(""), maskedPicturePathResult, sizeof(buffer), path);
GetPrivateProfileString(_T("Base"), _T("serverPort"), _T(""), serverPortResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("serverIP"), _T(""), serverIPResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("listenUDPPort"), _T(""), listenUDPPortResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("listenUDPIP"), _T(""), listenUDPIPResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("color"), _T(""), colorResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("shiftX"), _T(""), shiftXResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("shiftY"), _T(""), shiftYResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("isEyeWindowShow"), _T(""), isEyeWindowShowResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("isEyePositionWindowShow"), _T(""), isEyePositionWindowShowResult, 255, path);
GetPrivateProfileString(_T("Base"), _T("isCalibrate"), _T(""), isCalibrateResult, 255, path);
int shiftXint = _ttoi(shiftXResult);
int shiftYint = _ttoi(shiftYResult);
int serverPortint = _ttoi(serverPortResult);
int listenUDPPortint = _ttoi(listenUDPPortResult);
desiredColor = wcstoul(colorResult, NULL, 0x10);
char serverIPChar[255];
wcstombs(serverIPChar, serverIPResult, wcslen(serverIPResult) + 1);
char listenUDPIPChar[255];
wcstombs(listenUDPIPChar, listenUDPIPResult, wcslen(listenUDPIPResult) + 1);
bool isEyeWindowShowBool = false;
bool isEyePositionWindowShow = false;
bool isCalibrate = false;
if(_tcscmp(isEyeWindowShowResult, L"true") == 0){
isEyeWindowShowBool = true;
}
if(_tcscmp(isEyePositionWindowShowResult, L"true") == 0){
isEyePositionWindowShow = true;
}
if(_tcscmp(isCalibrateResult, L"true") == 0){
isCalibrate = true;
}
//getchar();
//return 0;
// screenMasker.exe 757575 checker4px.pgm stencil.pgm 23 45 Y"
// parse arguments
//E:\OrlovPA\screenMasker\screenmasker\screenMasker_bin\screenMasker_bin\screenMasker.exe 757575 bg.pgm stencil.pgm 0
//LPWSTR *argc;
//LPWSTR bgPath;
//wchar_t newBgPath[] = L"E:\\OrlovPA\\screenMasker\\screenmasker\\screenMasker_bin\\screenMasker_bin\\bg.pgm";
//wchar_t newBgPath[] = maskedPicturePathResult;
//LPWSTR stencilPath;
//wchar_t newStencilPath[] = L"E:\\OrlovPA\\screenMasker\\screenmasker\\screenMasker_bin\\screenMasker_bin\\stencil.pgm";
//int localstencilX, localstencilY, localCoursor;
//wchar_t myColor = '757575';
//const wchar_t * myColorAdress = &myColor;
//desiredColor = wcstoul(L"1a3399", NULL, 0x10);
//desiredColor = 757575;
isCoursor = 1;
// read background and stencil to buffers
UINT8 *bytes;
int width;
int height;
//bytes = readPGM(bgPath, &width, &height);
bytes = readPGM(maskedPicturePathResult, &width, &height);
//bytes = readPGM(newBgPath, &width, &height);
if(bytes == NULL)
{
return 1;
}
bgBmpBytes = bytes;
bgBmpWidth = width;
bgBmpHeight = height;
//bytes = readPGM(newStencilPath, &width, &height);
bytes = readPGM(stecilPicturePathResult, &width, &height);
if(bytes == NULL){
return 1;
}
stencilBmpBytes = bytes;
stencilBmpWidth = width;
stencilBmpHeight = height;
//----------------
POINT pt = {};
HMONITOR hMon;
MONITORINFO monitorInfo = {};
GetCursorPos(&pt);
hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
monitorInfo.cbSize = sizeof(MONITORINFO);
GetMonitorInfo(hMon, &monitorInfo);
mX = monitorInfo.rcMonitor.left;
mY = monitorInfo.rcMonitor.top;
mW = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
mH = monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top;
WNDCLASSEX wc;
MSG msg;
// Init wc
wc.cbSize = sizeof( WNDCLASSEX );
wc.style = 0;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = GetModuleHandle(0);
wc.hIcon = NULL;
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = NULL;
wc.hIconSm = NULL;
wc.lpszClassName = toString("animation_class");
wc.lpszMenuName = NULL;
// Register wc
if ( !RegisterClassEx(&wc) ) {
MessageBox( NULL, toString("Failed to register window class."), toString("Error"), MB_OK );
return 0;
}
// Make window
hwnd = CreateWindowEx(
//WS_EX_APPWINDOW,
WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TRANSPARENT,
toString("animation_class"),
toString("Animation"),
WS_POPUP | WS_SYSMENU,
mX, mY, mW, mH,
NULL, NULL, GetModuleHandle(0), NULL );
assert(hwnd);
/*
RECT rcClient, rcWindow;
POINT ptDiff;
// Get window and client sizes
GetClientRect( hwnd, &rcClient );
GetWindowRect( hwnd, &rcWindow );
// Find offset between window size and client size
ptDiff.x = (rcWindow.right - rcWindow.left) - rcClient.right;
ptDiff.y = (rcWindow.bottom - rcWindow.top) - rcClient.bottom;
// Resize client
MoveWindow( hwnd, rcWindow.left, rcWindow.top, width + ptDiff.x, height + ptDiff.y, false);
//UpdateLayeredWindow(hwnd, NULL, &ptDst, &siz, hdcOutBmp, &ptZero, 0, &blendFunc, ULW_ALPHA);
//SetLayeredWindowAttributes(hwnd, RGB(0, 0, 0), 0x0, LWA_COLORKEY);
*/
ShowWindow( hwnd, SW_SHOWDEFAULT );
UpdateWindow( hwnd );
initGpuResources( bgBmpBytes,
stencilBmpBytes,
bgBmpWidth,
bgBmpHeight,
stencilBmpHeight,
stencilBmpWidth,
mW,
mH );
//****************************
AccuracyStruct accuracyData;
SystemInfoStruct systemInfoData;
CalibrationStruct calibrationData;
int ret_calibrate = 0, ret_validate = 0, ret_connect = 0;
char c = ' ';
char repeat = ' ';
std::cout << "Output from iViewXAPI Demo"<< std::endl;
// define logger
iV_SetLogger(1, "ScreenMasker.txt");
std::cout << "ScreenMasker on iViewX API" << std::endl;
// connect to iViewX
ret_connect = iV_Connect(serverIPChar, serverPortint, listenUDPIPChar, listenUDPPortint);
switch(ret_connect)
{
case RET_SUCCESS:
std::cout << "Connection was established successfully" << std::endl;
// read out meta data from iViewX
std::cout << "GetSystemInfo: " << iV_GetSystemInfo(&systemInfoData) << std::endl;
std::cout << "SystemInfo ETSystem: " << systemInfoData.iV_ETDevice << std::endl;
std::cout << "SystemInfo iV_Version: " << systemInfoData.iV_MajorVersion << "." << systemInfoData.iV_MinorVersion << "." << systemInfoData.iV_Buildnumber << std::endl;
std::cout << "SystemInfo API_Version: " << systemInfoData.API_MajorVersion << "." << systemInfoData.API_MinorVersion << "." << systemInfoData.API_Buildnumber << std::endl;
std::cout << "SystemInfo samplerate: " << systemInfoData.samplerate << std::endl;
break;
case ERR_COULD_NOT_CONNECT:
std::cout << "Connection could not be established" << std::endl;
break;
case ERR_WRONG_PARAMETER:
std::cout << "Wrong Parameter used" << std::endl;
break;
default:
std::cout << "Any other error appeared" << std::endl;
return 0;
}
if(ret_connect == RET_SUCCESS)
{
calibrationData.method = 5;
calibrationData.speed = 0;
calibrationData.displayDevice = 0;
calibrationData.targetShape = 20;
calibrationData.foregroundBrightness = 250;
calibrationData.backgroundBrightness = 100;
calibrationData.autoAccept = 1;
calibrationData.targetSize = 10;
calibrationData.visualization = 1;
strcpy(calibrationData.targetFilename, "");
iV_SetupCalibration(&calibrationData);
// start calibration
//std::cout << "Do you want to calibrate? (y)es | (n)o" << std::endl;
//c = getchar();
if(isCalibrate){
ret_calibrate = iV_Calibrate();
switch(ret_calibrate){
case RET_SUCCESS:
std::cout << "Calibration done successfully" << std::endl;
// start validation
ret_validate = iV_Validate();
break;
case ERR_NOT_CONNECTED:
std::cout << "iViewX is not reachable" << std::endl;
break;
case ERR_WRONG_PARAMETER:
std::cout << "Wrong Parameter used" << std::endl;
break;
case ERR_WRONG_DEVICE:
std::cout << "Not possible to calibrate connected Eye Tracking System" << std::endl;
break;
default:
std::cout << "An unknown error appeared" << std::endl;
break;
}
}
// show accuracy only if validation was successful
if(ret_validate == RET_SUCCESS){
std::cout << "iV_GetAccuracy: " << iV_GetAccuracy(&accuracyData, 0) << std::endl;
std::cout << "AccuracyData DevX: " << accuracyData.deviationLX << " DevY: " << accuracyData.deviationLY << std::endl;
//getchar();
}
if(isEyeWindowShowBool){
iV_ShowEyeImageMonitor();
}
if(isEyePositionWindowShow){
iV_ShowTrackingMonitor();
iV_ShowSceneVideoMonitor();
}
// start data output via callback function
// define a callback function for receiving samples
iV_SetSampleCallback(SampleCallbackFunction);
iV_SetTrackingMonitorCallback(TrackingMonitorCallbackFunction);
while ( GetMessage(&msg, 0, 0, NULL) > 0 ) {
TranslateMessage( &msg );
DispatchMessage( &msg );
}
/*
getchar();
iV_SetSampleCallback(NULL);
iV_SetTrackingMonitorCallback(NULL);
std::cout << "iV_Disconnect: " << iV_Disconnect() << std::endl;
getchar();
*/
}
freeGpuResources();
fclose(hLog);
return 0;
}
