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); } }