void Libdc1394SequenceGrabber::setFeature(dc1394feature_t feature, float value)
{
if (!_camera) return;
dc1394bool_t is_present;
dc1394error_t err;
dc1394_feature_is_present(_camera, feature, &is_present);
if (is_present == DC1394_FALSE)
return;
dc1394feature_mode_t current_mode = (value == -1.0) ? DC1394_FEATURE_MODE_AUTO : DC1394_FEATURE_MODE_MANUAL;
err = dc1394_feature_set_mode(_camera, feature, current_mode);
checkSuccess(err, "dc1394_feature_set_mode failed");
if (value == -1.0)
return;
uint32_t min, max, int_value;
dc1394_feature_get_boundaries(_camera, feature, &min, &max);
int_value = min + value / 1000.0 * (max-min);
// std::cout << feature << " value: " << int_value << " min: " << min << " max: " << max << std::endl;
err = dc1394_feature_set_value(_camera, feature, int_value);
checkSuccess(err, "dc1394_feature_set_value failed");
}
void Libdc1394SequenceGrabber::idle()
{
dc1394error_t err;
dc1394video_frame_t *last_frame(NULL), *frame(NULL);
if (!_camera) {
fakeTracking();
return;
}
do{
err = dc1394_capture_dequeue(_camera, DC1394_CAPTURE_POLICY_POLL, &frame);
if (frame) {
if (last_frame)
err=dc1394_capture_enqueue(_camera, last_frame);
last_frame = frame;
}
} while (frame);
checkSuccess(err, "dc1394_capture_dequeue failed");
if (_firstFrame) {
setupBayer();
_firstFrame = false;
}
if (last_frame) {
processCameraImageData( last_frame->image );
newFrameAvailable();
err=dc1394_capture_enqueue(_camera, last_frame);
checkSuccess(err, "dc1394_capture_enqueue failed");
}
}
bool Libdc1394SequenceGrabber::initFrameRate(unsigned int rate)
{
msg(osg::INFO) << "initFrameRate" << std::endl;
if (!_camera) return false;
if (_format7) {
uint32_t bit_size;
dc1394_get_color_coding_bit_size(_sourceFormat,&bit_size);
int packet_size = DC1394_USE_MAX_AVAIL;
if(rate != 0) {
double bus_period;
if(_speed == DC1394_ISO_SPEED_800) {
bus_period = 0.0000625;
}
else {
bus_period = 0.000125;
}
int num_packets = (int)(1.0/(bus_period*rate)+0.5);
packet_size = ((_roi.width - _roi.x)*(_roi.height - _roi.y)*bit_size + (num_packets*8) - 1) / (num_packets*8);
}
dc1394error_t err = dc1394_format7_set_packet_size(_camera, _videomode, packet_size);
checkSuccess(err, "dc1394_format7_set_packet_size failed");
err = dc1394_format7_set_roi(_camera, _videomode, _sourceFormat, packet_size, _roi.x,_roi.y,_roi.width,_roi.height);
checkSuccess(err, "dc1394_format7_set_roi failed");
return (err == DC1394_SUCCESS);
}
dc1394framerates_t framerates;
dc1394error_t err=dc1394_video_get_supported_framerates(_camera,_videomode, &framerates);
checkSuccess(err, "dc1394_video_get_supported_framerates failed");
dc1394framerate_t framerate=framerates.framerates[framerates.num-1];
switch (rate) {
case 15:
framerate = DC1394_FRAMERATE_15;
break;
case 30:
framerate = DC1394_FRAMERATE_30;
break;
case 60:
framerate = DC1394_FRAMERATE_60;
break;
case 120:
framerate = DC1394_FRAMERATE_120;
break;
case 240:
framerate = DC1394_FRAMERATE_240;
}
err=dc1394_video_set_framerate(_camera, framerate);
checkSuccess(err, "dc1394_video_set_framerate failed");
return (err == DC1394_SUCCESS);
}
void Libdc1394SequenceGrabber::initCapture()
{
msg(osg::INFO) << "initCapture" << std::endl;
if (!_camera) return;
dc1394error_t err;
err=dc1394_video_set_iso_speed(_camera, _speed);
checkSuccess(err, "dc1394_video_set_iso_speed failed");
err=dc1394_capture_setup(_camera, 4, DC1394_CAPTURE_FLAGS_DEFAULT);
checkSuccess(err, "dc1394_capture_setup failed");
}
void Libdc1394SequenceGrabber::stop()
{
msg(osg::INFO) << "stop" << std::endl;
setRunning(false);
dc1394error_t err;
err=dc1394_video_set_transmission(_camera, DC1394_OFF);
checkSuccess(err, "dc1394_video_set_transmission failed");
dc1394_capture_stop(_camera);
}
void APRManager::init()
{
if (!initialised)
{
checkSuccess(apr_initialize());
initialised = true;
}
else
{
CFD_EXCEPTION("Attempted to initialise APRManager multiple times.");
}
}
void Libdc1394SequenceGrabber::start()
{
msg(osg::INFO) << "start" << std::endl;
dc1394error_t err;
initCapture();
if (!_camera) return;
err=dc1394_video_set_transmission(_camera, DC1394_ON);
checkSuccess(err, "dc1394_video_set_transmission failed");
setRunning(true);
}
void TeachingLoginDialog::checkUser()
{
if(getServerSetting()){
if(ui->passWord->text().isEmpty()
|| ui->passWord->text().isNull()){
QMessageBox::information(this,PASSWORDEMPTY,PASSWORDEMPTYPROMPT,QMessageBox::Ok);
ui->passWord->setFocus();
}
else{
mainWin->settingSever(serverIP,serverPort);
if(mainWin->initDatabase()){
if(mainWin->checkLoginingUser(ui->passWord->text())){
mainWin->setServerHost(serverIP);
checkSuccess();
}
else{
QMessageBox::information(this,PASSWORDERRORPROMPT,PASSWORDFAILUREPROMPT,QMessageBox::Ok);
ui->passWord->clear();
ui->passWord->setFocus();
}
}
}
}
}
int CVC_cl::buildCV(const Mat& lImg, const Mat& rImg, cl_mem *memoryObjects)
{
lImgRGB = new Mat[lImg.channels()];
rImgRGB = new Mat[rImg.channels()];
split(lImg, lImgRGB);
split(rImg, rImgRGB);
cvtColor(lImg, lGray, CV_RGB2GRAY);
cvtColor(rImg, rGray, CV_RGB2GRAY);
/* Map the input memory objects to host side pointers. */
bool EnqueueMapBufferSuccess = true;
// if(imgType == CV_32F)
// {
//Sobel filter to compute X gradient <-- investigate Mali Sobel OpenCL kernel
Sobel( lGray, lGrdX, CV_32F, 1, 0, 1 ); // ex time 16 -17ms
Sobel( rGray, rGrdX, CV_32F, 1, 0, 1 ); // for both
lGrdX += 0.5;
rGrdX += 0.5;
cl_float *clbuffer_lImgRGB[3], *clbuffer_rImgRGB[3];
for (int i = 0; i < channels; i++)
{
clbuffer_lImgRGB[i] = (cl_float*)clEnqueueMapBuffer(*commandQueue, memoryObjects[i], CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, bufferSize_2D, 0, NULL, NULL, &errorNumber);
EnqueueMapBufferSuccess &= checkSuccess(errorNumber);
clbuffer_rImgRGB[i] = (cl_float*)clEnqueueMapBuffer(*commandQueue, memoryObjects[i+channels], CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, bufferSize_2D, 0, NULL, NULL, &errorNumber);
EnqueueMapBufferSuccess &= checkSuccess(errorNumber);
memcpy(clbuffer_lImgRGB[i], lImgRGB[i].data, bufferSize_2D);
memcpy(clbuffer_rImgRGB[i], rImgRGB[i].data, bufferSize_2D);
}
// }
// else if(imgType == CV_8U)
// {
// //Sobel filter to compute X gradient
// Sobel( lGray, lGrdX, CV_8U, 1, 0, 1 );
// Sobel( rGray, rGrdX, CV_8U, 1, 0, 1 );
// lGrdX += 0.5;
// rGrdX += 0.5;
//
// cl_uchar *clbuffer_lImgRGB[3], *clbuffer_rImgRGB[3];
// //Six 1-channel 2D buffers W*H
// for (int i = 0; i < channels; i++)
// {
// clbuffer_lImgRGB[i] = (cl_uchar*)clEnqueueMapBuffer(*commandQueue, memoryObjects[i], CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, bufferSize_2D, 0, NULL, NULL, &errorNumber);
// EnqueueMapBufferSuccess &= checkSuccess(errorNumber);
// clbuffer_rImgRGB[i] = (cl_uchar*)clEnqueueMapBuffer(*commandQueue, memoryObjects[i+channels], CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, bufferSize_2D, 0, NULL, NULL, &errorNumber);
// EnqueueMapBufferSuccess &= checkSuccess(errorNumber);
//
// memcpy(clbuffer_lImgRGB[i], lImgRGB[i].data, bufferSize_2D);
// memcpy(clbuffer_rImgRGB[i], rImgRGB[i].data, bufferSize_2D);
// }
// }
//Two 1-channel 2D buffers W*H
cl_uchar *clbuffer_lGrdX = (cl_uchar*)clEnqueueMapBuffer(*commandQueue, memoryObjects[CVC_LGRDX], CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, bufferSize_2D, 0, NULL, NULL, &errorNumber);
EnqueueMapBufferSuccess &= checkSuccess(errorNumber);
cl_uchar *clbuffer_rGrdX = (cl_uchar*)clEnqueueMapBuffer(*commandQueue, memoryObjects[CVC_RGRDX], CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, bufferSize_2D, 0, NULL, NULL, &errorNumber);
EnqueueMapBufferSuccess &= checkSuccess(errorNumber);
if (!EnqueueMapBufferSuccess)
{
cleanUpOpenCL(NULL, NULL, program, NULL, NULL, 0);
cerr << "Mapping memory objects failed " << __FILE__ << ":"<< __LINE__ << endl;
}
//printf("CVC_cl: Copying data to OpenCL memory space\n");
memcpy(clbuffer_lGrdX, lGrdX.data, bufferSize_2D);
memcpy(clbuffer_rGrdX, rGrdX.data, bufferSize_2D);
int arg_num = 0;
/* Setup the kernel arguments. */
bool setKernelArgumentsSuccess = true;
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_LIMGR]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_LIMGG]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_LIMGB]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_RIMGR]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_RIMGG]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_RIMGB]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_LGRDX]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CVC_RGRDX]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_int), &height));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_int), &width));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CV_LCV]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, arg_num++, sizeof(cl_mem), &memoryObjects[CV_RCV]));
if (!setKernelArgumentsSuccess)
{
cleanUpOpenCL(NULL, NULL, NULL, NULL, NULL, 0);
cerr << "Failed setting OpenCL kernel arguments. " << __FILE__ << ":"<< __LINE__ << endl;
}
if(OCL_STATS) printf("CVC_cl: Running CVC Kernels\n");
/* Enqueue the kernel */
if (!checkSuccess(clEnqueueNDRangeKernel(*commandQueue, kernel, 3, NULL, globalWorksize, NULL, 0, NULL, &event)))
{
cleanUpOpenCL(NULL, NULL, NULL, NULL, NULL, 0);
cerr << "Failed enqueuing the kernel. " << __FILE__ << ":"<< __LINE__ << endl;
return 1;
}
/* Wait for completion */
if (!checkSuccess(clFinish(*commandQueue)))
{
cleanUpOpenCL(NULL, NULL, NULL, NULL, NULL, 0);
cerr << "Failed waiting for kernel execution to finish. " << __FILE__ << ":"<< __LINE__ << endl;
return 1;
}
/* Print the profiling information for the event. */
if(OCL_STATS) printProfilingInfo(event);
/* Release the event object. */
if (!checkSuccess(clReleaseEvent(event)))
{
cleanUpOpenCL(*context, *commandQueue, program, NULL, NULL, 0);
cerr << "Failed releasing the event object. " << __FILE__ << ":"<< __LINE__ << endl;
return 1;
}
return 0;
}
CVC_cl::CVC_cl(cl_context* context, cl_command_queue* commandQueue, cl_device_id device,
Mat* I, const int d) : maxDis(d),
context(context), commandQueue(commandQueue)
{
//printf("OpenCL Colours and Gradients method for Cost Computation\n");
//OpenCL Setup
program = 0;
kernel = 0;
// imgType = I->type() & CV_MAT_DEPTH_MASK;
if (!createProgram(*context, device, FILE_CVC_PROG, &program))
{
cleanUpOpenCL(NULL, NULL, program, NULL, NULL, 0);
cerr << "Failed to create OpenCL program." << __FILE__ << ":"<< __LINE__ << endl;
}
width = (cl_int)I->cols;
height = (cl_int)I->rows;
// channels = (cl_int)I->channels();
// if(imgType == CV_32F)
// {
strcpy(kernel_name, "cvc_float_nv");
//strcpy(kernel_name, "cvc_float_v4");
bufferSize_2D = width * height * sizeof(cl_float);
bufferSize_3D = width * height * maxDis * sizeof(cl_float);
//cvc_uchar_nv
globalWorksize[0] = (size_t)width;
//cvc_uchar_v4
// globalWorksize[0] = (size_t)width/4;
globalWorksize[1] = (size_t)height;
globalWorksize[2] = (size_t)maxDis;
// }
// else if(imgType == CV_8U)
// {
// strcpy(kernel_name, "cvc_uchar_vx");
// //strcpy(kernel_name, "cvc_uchar_v16");
// //strcpy(kernel_name, "cvc_uchar_nv");
//
// bufferSize_2D = width * height * sizeof(cl_uchar);
// bufferSize_3D = width * height * maxDis * sizeof(cl_uchar);
//
// //cvc_uchar_vx
// globalWorksize[0] = (size_t)height;
// globalWorksize[1] = (size_t)1;
// //cvc_uchar_v16
//// globalWorksize[0] = (size_t)width/16;
// //cvc_uchar_nv
//// globalWorksize[0] = (size_t)width;
//// globalWorksize[1] = (size_t)height;
//
// globalWorksize[2] = (size_t)maxDis;
//
// }
// else{
// printf("CVC_cl: Error - Unrecognised data type in processing! (CVC_cl)\n");
// exit(1);
// }
kernel = clCreateKernel(program, kernel_name, &errorNumber);
if (!checkSuccess(errorNumber))
{
cleanUpOpenCL(NULL, NULL, NULL, NULL, NULL, 0);
cerr << "Failed to create OpenCL kernel. " << __FILE__ << ":"<< __LINE__ << endl;
exit(1);
}
else{
printf("CVC_cl: OpenCL kernels created.\n");
}
/* An event to associate with the Kernel. Allows us to retreive profiling information later. */
event = 0;
}
Libdc1394SequenceGrabber::Libdc1394SequenceGrabber(const std::string& name, unsigned int w, unsigned int h, unsigned int rate)
: cefix::SequenceGrabber(name, w, h, rate),
_context(Libdc1394Context::get()),
_camera(NULL),
_firstFrame(true),
_bayerMethod(DC1394_BAYER_METHOD_BILINEAR),
_bayerPattern(DC1394_COLOR_FILTER_RGGB)
{
msg(osg::INFO) << "LibdcSequenceGrabber " << name << std::endl;
setImage(new osg::ImageStream());
getImage()->setOrigin(osg::Image::TOP_LEFT);
uint64_t uid = 0;
bool grey = false;
_format7 = false;
int format_7_format_delta(0);
if (name.empty() == false) {
std::vector<std::string> parts;
cefix::strTokenize(name,parts,":");
uid=cefix::hexToLong(parts[0]);
for(unsigned int i = 1; i < parts.size(); ++i) {
std::string part = cefix::strToLower(parts[i]);
if (part == "grey")
grey = true;
else if (part == "format7") {
_format7 = true;
if (i+1 < parts.size()) {
format_7_format_delta = atoi(parts[i+1].c_str());
++i;
}
}
}
}
if (_roi.height == 0) _roi.height = h;
if (_roi.width == 0) _roi.width = w;
initCamera(uid);
if (_camera) {
unsigned int video_mode(0);
unsigned int color_mode(0);
if (_format7)
{
video_mode = DC1394_VIDEO_MODE_FORMAT7_0+format_7_format_delta;
color_mode = (!grey) ? DC1394_COLOR_CODING_RGB8 : DC1394_COLOR_CODING_MONO8;
}
if (!initVideoMode(w,h, grey, video_mode, color_mode)) {
grey = !grey;
msg(osg::INFO) << " could not find suitable video mode, toggling grey/color " << std::endl;
if (!initVideoMode(w,h, grey)) {
msg(osg::WARN) << "could not find suitable video mode for " << w << "x" << h << std::endl;
}
}
initFrameRate(rate);
dc1394error_t err;
if (_format7) {
err = dc1394_format7_set_color_coding(_camera, _videomode, (dc1394color_coding_t)color_mode);
checkSuccess(err, "dc1394_format7_set_color_coding failed");
}
if (_format7) {
err = dc1394_format7_get_image_size(_camera, _videomode, &w, &h);
checkSuccess(err, "dc1394_format7_get_image_size failed");
}
else
{
err = dc1394_get_image_size_from_video_mode(_camera, _videomode, &w, &h);
checkSuccess(err, "dc1394_get_image_size_from_video_mode failed");
}
}
if (grey) {
getImage()->allocateImage(w,h,1,GL_LUMINANCE, GL_UNSIGNED_BYTE);
} else {
getImage()->allocateImage(w,h,1,GL_RGB, GL_UNSIGNED_BYTE);
}
_grey = grey;
}
bool Libdc1394SequenceGrabber::initVideoMode(unsigned int w, unsigned int h, bool grey, unsigned int videomode, unsigned int color_mode)
{
msg(osg::INFO) << "initVideoMode" << std::endl;
std::vector<dc1394video_mode_t> suitable_modes;
if (videomode != 0)
{
suitable_modes.push_back((dc1394video_mode_t)videomode);
}
else
{
if (w == 320) {
if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_320x240_YUV422);
} else if (w == 640) {
//if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_640x480_RGB8);
//if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_640x480_YUV411);
if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_640x480_YUV422);
if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_640x480_MONO8);
//if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_640x480_MONO16);
} else if (w == 800) {
//if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_800x600_RGB8);
if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_800x600_YUV422);
if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_800x600_MONO8);
//if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_800x600_MONO16);
} else if (w == 1024) {
//if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1024x768_RGB8);
if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1024x768_YUV422);
if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1024x768_MONO8);
//if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1024x768_MONO16);
} else if (w == 1280) {
//if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1280x960_RGB8);
if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1280x960_YUV422);
if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1280x960_MONO8);
//if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1280x960_MONO16);
} else if (w == 1600) {
//if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1600x1200_RGB8);
if (!grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1600x1200_YUV422);
if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1600x1200_MONO8);
//if (grey) suitable_modes.push_back(DC1394_VIDEO_MODE_1600x1200_MONO16);
}
}
dc1394video_modes_t video_modes;
dc1394error_t err=dc1394_video_get_supported_modes(_camera,&video_modes);
checkSuccess(err, "dc1394_video_get_supported_modes failed");
for (unsigned int i = 0;i < video_modes.num;i++)
{
for(unsigned int j=0; j < suitable_modes.size(); ++j) {
if (video_modes.modes[i] == suitable_modes[j])
{
// videmodus gefunden, gleich setzen
_videomode = video_modes.modes[i];
err = dc1394_video_set_mode(_camera, video_modes.modes[i]);
checkSuccess(err,"dc1394_video_set_mode failed");
if (color_mode == 0) {
err = dc1394_get_color_coding_from_video_mode(_camera, _videomode, &_sourceFormat);
checkSuccess(err, "dc1394_get_color_coding_from_video_mode failed");
} else {
_sourceFormat = (dc1394color_coding_t)(color_mode);
}
return true;
}
}
}
return false;
}
inline void vector_sum(const int arraySize,
const double* inputA,
const double* inputB,
double* output)
{
/* Allocate memory buffers */
/*
* Ask the OpenCL implementation to allocate buffers for the data.
* We ask the OpenCL implemenation to allocate memory rather than
* allocating it on the CPU to avoid having to copy the data later.
* The read/write flags relate to accesses to the memory from within
* the kernel.
*/
bool createMemoryObjectSuccess = true;
int numberOfMemoryObjects = 3;
cl_mem memoryObjects[3] = {0, 0, 0};
int errorNumber = 0;
int bufferSize = arraySize*sizeof(double);
memoryObjects[0] = clCreateBuffer(context,
CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
bufferSize, (void*)inputA, &errorNumber);
checkErr(errorNumber, "Failed to create buffer, 1.");
memoryObjects[1] = clCreateBuffer(context,
CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
bufferSize, (void*)inputB, &errorNumber);
checkErr(errorNumber, "Failed to create buffer, 2.");
memoryObjects[2] = clCreateBuffer(context,
CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR,
bufferSize, output, &errorNumber);
checkErr(errorNumber, "Failed to create buffer, 3.");
/* Enqueue commands and kernels */
/* Enqueue to the command queues the commands that control the sequence
* and synchronization of kernel execution, reading and writing of data,
* and manipulation of memory objects
*/
/* Execute a kernel function */
/* Call clSetKernelArg() for each parameter in the kernel */
bool setKernelArgumentsSuccess = true;
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, 0,
sizeof(cl_mem), &memoryObjects[0]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, 1,
sizeof(cl_mem), &memoryObjects[1]));
setKernelArgumentsSuccess &= checkSuccess(clSetKernelArg(kernel, 2,
sizeof(cl_mem), &memoryObjects[2]));
if (not setKernelArgumentsSuccess) {
cleanUpOpenCL();
std::cerr << "Failed setting OpenCL kernel arguments. " << __FILE__
<< ":"<< __LINE__ << std::endl;
exit(1);
}
/* Determine the work-group size and index space for the kernel */
const size_t globalWorkSize[1] = {arraySize};
const size_t localWorkSize[1] = { 1 };
/* Enqueue the kernel for execution in the command queue */
//for (int j = 0; j < ITER; j++) {
if (not checkSuccess(clEnqueueNDRangeKernel(commandQueue, kernel, 1,
NULL, globalWorkSize, localWorkSize, 0, NULL, NULL))) {
cleanUpOpenCL();
std::cerr << "Failed enqueuing the kernel. " << __FILE__ << ":"
<< __LINE__ <<std::endl;
exit(1);
}
//}
/* Get a pointer to the output data */
output = (double*)clEnqueueMapBuffer(commandQueue,
memoryObjects[2], CL_TRUE, CL_MAP_READ, 0,
arraySize, 0, NULL, NULL, &errorNumber);
if (not checkSuccess(errorNumber)) {
cleanUpOpenCL();
std::cerr << "Failed to map buffer " << __FILE__ << ":"
<< __LINE__ << std::endl;
exit(1);
}
/* Wait for kernel execution */
if (not checkSuccess(clFinish(commandQueue))) {
cleanUpOpenCL();
std::cerr << "Failed waiting for kernel execution to finish. "
<< __FILE__ << ":"<< __LINE__ << std::endl;
exit(1);
}
/* Unmap the memory objects as we finished using them in the CPU */
if (not checkSuccess(clReleaseMemObject(memoryObjects[0]))) {
cleanUpOpenCL();
std::cerr << "Unmapping memory objects failed " << __FILE__ << ":"
<< __LINE__ << std::endl;
exit(1);
}
if (not checkSuccess(clReleaseMemObject(memoryObjects[1]))) {
cleanUpOpenCL();
std::cerr << "Unmapping memory objects failed " << __FILE__ << ":"
<< __LINE__ << std::endl;
exit(1);
}
if (not checkSuccess(clEnqueueUnmapMemObject(commandQueue,
memoryObjects[2], output, 0, NULL, NULL))) {
cleanUpOpenCL();
std::cerr << "Unmapping memory objects failed " << __FILE__ << ":"
<< __LINE__ << std::endl;
exit(1);
}
}
