void OpenCL::init(int isGPU)
{
if (isGPU)
getDevices(CL_DEVICE_TYPE_GPU);
else
getDevices(CL_DEVICE_TYPE_CPU);
buildKernel();
}
int kickstartFromRemovable(char *kssrc) {
struct device ** devices;
char *p, *kspath;
int i, rc;
logMessage(INFO, "doing kickstart from removable media");
devices = getDevices(DEVICE_DISK);
/* usb can take some time to settle, even with the various hacks we
* have in place. some systems use portable USB CD-ROM drives, try to
* make sure there really isn't one before bailing. */
for (i = 0; !devices && i < 10; ++i) {
logMessage(INFO, "sleeping to wait for a USB disk");
sleep(2);
devices = getDevices(DEVICE_DISK);
}
if (!devices) {
logMessage(ERROR, "no disks");
return 1;
}
for (i = 0; devices[i]; i++) {
if (devices[i]->priv.removable == 1) {
logMessage(INFO, "first removable media is %s", devices[i]->device);
break;
}
}
if (!devices[i] || (devices[i]->priv.removable == 0)) {
logMessage(ERROR, "no removable devices");
return 1;
}
/* format is floppy:[/path/to/ks.cfg] */
kspath = "";
p = strchr(kssrc, ':');
if (p)
kspath = p + 1;
if (!p || strlen(kspath) < 1)
kspath = "/ks.cfg";
if ((rc=getKickstartFromBlockDevice(devices[i]->device, kspath))) {
if (rc == 3) {
startNewt();
newtWinMessage(_("Error"), _("OK"),
_("Cannot find ks.cfg on removable media."));
}
return 1;
}
return 0;
}
void MidiSession::openOutputDevice(std::string device)
{
auto numMidiInputs = Pm_CountDevices();
auto devices = getDevices();
for(auto i = 0; i < numMidiInputs; i++)
{
if(devices[i] == device)
{
if(!Pm_GetDeviceInfo(i)->opened)
error = Pm_OpenOutput(&midiStream, i, nullptr, 3, nullptr, nullptr, 0);
else
std::cout<<"Device is already opened"<<std::endl;
if(error != pmNoError)
{
std::cout<<"Trying to open device: "<<devices[i]<<std::endl;
std::cout<<Pm_GetErrorText(error)<<std::endl;
return;
}
midiThread = std::thread(&MidiSession::read, this);
midiThread.detach();
return;
}
}
}
/*
Name DirectInput::DirectInput
Syntax DirectInput()
Brief DirectInput constructor gets the input devices and initialises input variables
*/
DirectInput::DirectInput()
: diObject_(0), keyboardDevice_(0), mouseDevice_(0), mouseX_(0), mouseY_(0), mouseZ_(0),
mouseLeftUp_(true), mouseLeftDown_(false), mouseRightUp_(true), mouseRightDown_(false),
mouseLeftPressed_(false), mouseRightPressed_(false), KEYBOARD_BUFFER_SIZE(16)
{
if (!getDevices())
{
throw new std::exception("getDevices failed.");
}
// Initialise the key events arrays
for (int i = 0; i < 256; ++i)
{
heldKeys_[i] = false;
}
for (int i = 0; i < 256; ++i)
{
pressedKeys_[i] = false;
}
// Initialise the mouse button flags
mouseLeftUp_ = true;
mouseLeftDown_ = false;
mouseRightUp_ = true;
mouseRightDown_ = false;
mouseLeftPressed_ = false;
mouseRightPressed_ = false;
}
int
main(int argc, const char *argv[])
{
char **ppsz_cd_drives=NULL, **c;
cdio_log_set_handler (log_handler);
/* Print out a list of CD-drives */
printf("All CD-ROM/DVD drives...\n");
ppsz_cd_drives = getDevices();
if (NULL != ppsz_cd_drives)
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("Drive %s\n", *c);
}
freeDeviceList(ppsz_cd_drives);
print_drive_class("All CD-ROM drives (again)", CDIO_FS_MATCH_ALL);
print_drive_class("CD-ROM drives with a CD-DA loaded...", CDIO_FS_AUDIO);
print_drive_class("CD-ROM drives with some sort of ISO 9660 filesystem...",
CDIO_FS_ANAL_ISO9660_ANY, true);
print_drive_class("(S)VCD drives...", CDIO_FS_ANAL_VCD_ANY, true);
return 0;
}
std::pair<std::vector<cl::Context>, std::vector<command_queue>>
queue_list(DevFilter &&filter, cl_command_queue_properties properties = 0) {
std::vector<cl::Context> context;
std::vector<command_queue> queue;
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
for(auto p = platforms.begin(); p != platforms.end(); p++) {
std::vector<cl::Device> device;
std::vector<cl::Device> dev_list;
p->getDevices(CL_DEVICE_TYPE_ALL, &dev_list);
for(auto d = dev_list.begin(); d != dev_list.end(); d++) {
if (!d->getInfo<CL_DEVICE_AVAILABLE>()) continue;
if (!filter(*d)) continue;
device.push_back(*d);
}
if (device.empty()) continue;
for(auto d = device.begin(); d != device.end(); d++)
try {
context.push_back(cl::Context(std::vector<cl::Device>(1, *d)));
queue.push_back(command_queue(context.back(), *d, properties));
} catch(const cl::Error&) {
// Something bad happened. Better skip this device.
}
}
return std::make_pair(context, queue);
}
static ENGINE *engine_qat(void)
{
ENGINE *ret = NULL;
unsigned int devmasks[] = { 0, 0, 0 };
DEBUG("[%s] engine_qat\n", __func__);
if (access(QAT_DEV, F_OK) != 0) {
QATerr(QAT_F_ENGINE_QAT, QAT_R_MEM_DRV_NOT_PRESENT);
return ret;
}
if (!getDevices(devmasks)) {
QATerr(QAT_F_ENGINE_QAT, QAT_R_QAT_DEV_NOT_PRESENT);
return ret;
}
ret = ENGINE_new();
if (!ret)
return NULL;
if (!bind_qat(ret, engine_qat_id)) {
WARN("qat engine bind failed!\n");
ENGINE_free(ret);
return NULL;
}
return ret;
}
void CubicSDR::setOffset(long long ofs) {
offset = ofs;
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_OFFSET);
command.llong_value = ofs;
pipeSDRCommand->push(command);
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
config.getDevice(dev->getDeviceId())->setOffset(ofs);
}
DeviceRef DeviceManager::findDeviceByKey( const string &key )
{
for( const auto &device : getDevices() ) {
if( device->getKey() == key )
return device;
}
return DeviceRef();
}
DeviceRef DeviceManager::findDeviceByName( const string &name )
{
for( const auto &device : getDevices() ) {
if( device->getName() == name )
return device;
}
return DeviceRef();
}
void CubicSDR::setDirectSampling(int mode) {
directSamplingMode = mode;
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_DIRECT_SAMPLING);
command.llong_value = mode;
pipeSDRCommand->push(command);
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
config.getDevice(dev->getDeviceId())->setDirectSampling(mode);
}
InputDeviceRef Input::findDeviceByNameContains( const std::string &nameFragment )
{
const std::vector<InputDeviceRef>& devices = getDevices();
for (size_t i = 0; i < devices.size(); ++i) {
if (devices[i]->getName().find(nameFragment) != std::string::npos)
return devices[i];
}
return InputDeviceRef();
}
InputDeviceRef Input::findDeviceByName( const std::string &name )
{
const std::vector<InputDeviceRef>& devices = getDevices();
for (size_t i = 0; i < devices.size(); ++i) {
if (devices[i]->getName() == name)
return devices[i];
}
return InputDeviceRef();
}
Serial::Device Serial::findDeviceByName( const std::string &name, bool forceRefresh )
{
const std::vector<Serial::Device> &devices = getDevices( forceRefresh );
for( std::vector<Serial::Device>::const_iterator deviceIt = devices.begin(); deviceIt != devices.end(); ++deviceIt ) {
if( deviceIt->getName() == name )
return *deviceIt;
}
return Serial::Device();
}
Serial::Device Serial::findDeviceByNameContains( const std::string &searchString, bool forceRefresh )
{
const std::vector<Serial::Device> &devices = getDevices( forceRefresh );
for( std::vector<Serial::Device>::const_iterator deviceIt = devices.begin(); deviceIt != devices.end(); ++deviceIt ) {
if( deviceIt->getName().find( searchString ) != std::string::npos )
return *deviceIt;
}
return Serial::Device();
}
vector<DeviceRef> Device::getInputDevices()
{
vector<DeviceRef> result;
for( const auto &dev : getDevices() ) {
if( dev->getNumInputChannels() > 0 )
result.push_back( dev );
}
return result;
}
int CubicSDR::getPPM() {
if (sdrThread->getDeviceId() < 0) {
return 0;
}
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
SDRThreadCommand command_ppm(SDRThreadCommand::SDR_THREAD_CMD_SET_PPM);
ppm = config.getDevice(dev->getDeviceId())->getPPM();
return ppm;
}
void
Studio::
resyncDeviceConnections(void)
{
// Sync all the device connections
DeviceList *devices = getDevices();
for (uint i = 0; i < devices->size(); ++i) {
DeviceId id = (*devices)[i]->getId();
QString connection = RosegardenSequencer::getInstance()->getConnection(id);
(*devices)[i]->setConnection(qstrtostr(connection));
}
}
string Device::printDevicesToString()
{
stringstream stream;
for( auto &device : getDevices() ) {
stream << "-- " << device->getName() << " --" << endl;
stream << "\t key: " << device->getKey() << endl;
stream << "\t inputs: " << device->getNumInputChannels() << ", outputs: " << device->getNumOutputChannels() << endl;
stream << "\t samplerate: " << device->getSampleRate() << ", frames per block: " << device->getFramesPerBlock() << endl;
}
return stream.str();
}
bool startApp( AppCtx *appCtx, WstCompositor *wctx )
{
bool result= false;
if ( appCtx )
{
appCtx->wctx= wctx;
#if !defined (WESTEROS_PLATFORM_EMBEDDED)
WstCompositorSetNativeWindow( appCtx->wctx, appCtx->nativeWindow );
#endif
if ( !WstCompositorGetIsNested( appCtx->wctx ) )
{
#if defined (WESTEROS_PLATFORM_EMBEDDED)
InputCtx *inputCtx= appCtx->inputCtx;
getDevices( inputCtx->deviceFds );
if ( inputCtx->deviceFds.size() > 0 )
{
inputCtx->wctx= wctx;
int rc= pthread_create( &appCtx->inputThreadId, NULL, inputThread, inputCtx );
if ( rc )
{
printf("unable to start input thread: error %d\n", rc );
}
}
#else
WstCompositorPointerEnter( appCtx->wctx );
#endif
}
if ( appCtx->isEmbedded )
{
appCtx->matrix[0]= 1.0f;
appCtx->matrix[5]= 1.0f;
appCtx->matrix[10]= 1.0f;
appCtx->matrix[15]= 1.0f;
appCtx->x= 0;
appCtx->y= 0;
appCtx->width= 1280;
appCtx->height= 720;
appCtx->alpha= 1.0f;
}
result= true;
}
return result;
}
void CubicSDR::setDevice(int deviceId) {
sdrThread->setDeviceId(deviceId);
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_DEVICE);
command.llong_value = deviceId;
pipeSDRCommand->push(command);
SDRDeviceInfo *dev = (*getDevices())[deviceId];
DeviceConfig *devConfig = config.getDevice(dev->getDeviceId());
setPPM(devConfig->getPPM());
setDirectSampling(devConfig->getDirectSampling());
setSwapIQ(devConfig->getIQSwap());
setOffset(devConfig->getOffset());
}
void CubicSDR::setPPM(int ppm_in) {
if (sdrThread->getDeviceId() < 0) {
return;
}
ppm = ppm_in;
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_PPM);
command.llong_value = ppm;
pipeSDRCommand->push(command);
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
config.getDevice(dev->getDeviceId())->setPPM(ppm_in);
}
static void
print_drive_class(const char *psz_msg, cdio_fs_anal_t bitmask,
bool b_any=false) {
char **ppsz_cd_drives=NULL, **c;
printf("%s...\n", psz_msg);
ppsz_cd_drives = getDevices(NULL, bitmask, b_any);
if (NULL != ppsz_cd_drives)
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("Drive %s\n", *c);
}
freeDeviceList(ppsz_cd_drives);
printf("-----\n");
}
Common::Error WindowsMusicPlugin::createInstance(MidiDriver **mididriver, MidiDriver::DeviceHandle dev) const {
int devIndex = 0;
bool found = false;
if (dev) {
MusicDevices i = getDevices();
for (MusicDevices::iterator d = i.begin(); d != i.end(); d++) {
if (d->getCompleteId().equals(MidiDriver::getDeviceString(dev, MidiDriver::kDeviceId))) {
found = true;
break;
}
devIndex++;
}
}
*mididriver = new MidiDriver_WIN(found ? devIndex : 0);
return Common::kNoError;
}
int checkLimitDevAccessValue(int *limitDevAccess, char *section_name)
{
unsigned int devmasks[] = { 0, 0, 0 };
char *dev_names[] = { DH89XXCC_NAME, DH895XCC_NAME, C2XXX_NAME };
char configFilePath[CONF_MAX_PATH];
char configKeyValue[CONF_MAX_LINE_LENGTH] = { 0 };
int configKeyValueSize = CONF_MAX_LINE_LENGTH;
int status;
int i, j;
if (!getDevices(devmasks)) {
*limitDevAccess = 0;
return 0;
}
for (j = 0; j < NUM_DEVICES_TYPES; j++)
for (i = 0; i < MAX_NUM_DEVICES; i++) {
if ((devmasks[j] & (1 << i))) {
sprintf(configFilePath, "/etc/%s_qa_dev%d.conf", dev_names[j],
i);
} else {
continue;
}
DEBUG("looking in %s\n", configFilePath);
status = confCryptoFindKeyValue(configFilePath, section_name,
"LimitDevAccess", configKeyValue,
configKeyValueSize);
if (status == CONF_FIND_KEY_SECTION_FOUND) {
/* if the SHIM section was found in the config file but no
LimitDevAccess setting,
LimitDevAccess is set to 0 */
*limitDevAccess = 0;
return 1;
} else if (status == CONF_FIND_KEY_KEY_FOUND) {
if (isdigit(configKeyValue[0])) {
*limitDevAccess = atoi(configKeyValue);
return 1;
}
}
}
*limitDevAccess = 0;
return 0;
}
std::vector<cl::Device> device_list(DevFilter&& filter) {
std::vector<cl::Device> device;
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
for(auto p = platforms.begin(); p != platforms.end(); p++) {
std::vector<cl::Device> dev_list;
p->getDevices(CL_DEVICE_TYPE_ALL, &dev_list);
for(auto d = dev_list.begin(); d != dev_list.end(); d++) {
if (!d->getInfo<CL_DEVICE_AVAILABLE>()) continue;
if (!filter(*d)) continue;
device.push_back(*d);
}
}
return device;
}
string V4L::getFrameGrabberOptions() {
string tmp = "Devices;";
vector<string>::iterator iter1;
vector<string> devices = getDevices();
/*przekazanie urzadzen*/
for (iter1 = devices.begin(); iter1 != devices.end(); iter1++)
tmp = tmp + (*iter1) + ";";
tmp = tmp + ";Channels;";
/*przekazanie kanalow*/
vector<string> channels = getChannels();
for (iter1 = channels.begin(); iter1 != channels.end(); iter1++)
tmp = tmp + (*iter1) + ";";
tmp = tmp + ";Palettes;";
vector<string> palettes = getPalettes();
for (iter1 = palettes.begin(); iter1 != palettes.end(); iter1++)
tmp = tmp + (*iter1) + ";";
tmp = tmp + ";Width;";
vector<string> width = getWidth();
for (iter1 = width.begin(); iter1 != width.end(); iter1++)
tmp = tmp + (*iter1) + ";";
tmp = tmp + ";Height;";
vector<string> height = getHeight();
for (iter1 = height.begin(); iter1 != height.end(); iter1++)
tmp = tmp + (*iter1) + ";";
tmp = tmp + ";Standard;";
vector<string> standard = getStandard();
for (iter1 = standard.begin(); iter1 != standard.end(); iter1++)
tmp = tmp + (*iter1) + ";";
cout << "poszlo" << endl;
return tmp;
}
int AtomicCounters::setupCL(void) {
cl_int status = 0;
cl_device_type dType;
if (sampleArgs->deviceType.compare("cpu") == 0) {
dType = CL_DEVICE_TYPE_CPU;
} else // deviceType = "gpu"
{
dType = CL_DEVICE_TYPE_GPU;
if (sampleArgs->isThereGPU() == false) {
std::cout << "GPU not found. Falling back to CPU" << std::endl;
dType = CL_DEVICE_TYPE_CPU;
}
}
cl_platform_id platform = NULL;
int retValue = getPlatform(platform, sampleArgs->platformId,
sampleArgs->isPlatformEnabled());
CHECK_ERROR(retValue, SDK_SUCCESS, "getPlatform() failed.");
// Display available devices.
retValue = displayDevices(platform, dType);
CHECK_ERROR(retValue, SDK_SUCCESS, "displayDevices() failed.");
cl_context_properties cps[3] = {CL_CONTEXT_PLATFORM,
(cl_context_properties)platform, 0};
context = clCreateContextFromType(cps, dType, NULL, NULL, &status);
CHECK_OPENCL_ERROR(status, "clCreateContextFromType failed.");
// getting device on which to run the sample
status = getDevices(context, &devices, sampleArgs->deviceId,
sampleArgs->isDeviceIdEnabled());
CHECK_ERROR(status, SDK_SUCCESS, "getDevices() failed ");
// Set device info of given cl_device_id
retValue = deviceInfo.setDeviceInfo(devices[sampleArgs->deviceId]);
CHECK_ERROR(retValue, SDK_SUCCESS, "SDKDeviceInfo::setDeviceInfo() failed");
// Check device extensions
if (!strstr(deviceInfo.extensions, "cl_ext_atomic_counters_32")) {
OPENCL_EXPECTED_ERROR(
"Device does not support cl_ext_atomic_counters_32 extension!");
}
if (!strstr(deviceInfo.extensions, "cl_khr_local_int32_base_atomics")) {
OPENCL_EXPECTED_ERROR(
"Device does not support cl_khr_local_int32_base_atomics extension!");
}
// Get OpenCL device version
std::string deviceVersionStr = std::string(deviceInfo.deviceVersion);
size_t vStart = deviceVersionStr.find(" ", 0);
size_t vEnd = deviceVersionStr.find(" ", vStart + 1);
std::string vStrVal = deviceVersionStr.substr(vStart + 1, vEnd - vStart - 1);
// Check of OPENCL_C_VERSION if device version is 1.1 or later
#ifdef CL_VERSION_1_1
if (deviceInfo.openclCVersion) {
// Exit if OpenCL C device version is 1.0
deviceVersionStr = std::string(deviceInfo.openclCVersion);
vStart = deviceVersionStr.find(" ", 0);
vStart = deviceVersionStr.find(" ", vStart + 1);
vEnd = deviceVersionStr.find(" ", vStart + 1);
vStrVal = deviceVersionStr.substr(vStart + 1, vEnd - vStart - 1);
if (vStrVal.compare("1.0") <= 0) {
OPENCL_EXPECTED_ERROR(
"Unsupported device! Required CL_DEVICE_OPENCL_C_VERSION as 1.1");
}
} else {
OPENCL_EXPECTED_ERROR(
"Unsupported device! Required CL_DEVICE_OPENCL_C_VERSION as 1.1");
}
#else
OPENCL_EXPECTED_ERROR(
"Unsupported device! Required CL_DEVICE_OPENCL_C_VERSION as 1.1");
#endif
// Setup application data
if (setupAtomicCounters() != SDK_SUCCESS) {
return SDK_FAILURE;
}
cl_command_queue_properties props = CL_QUEUE_PROFILING_ENABLE;
commandQueue = clCreateCommandQueue(context, devices[sampleArgs->deviceId],
props, &status);
CHECK_OPENCL_ERROR(status, "clCreateCommandQueue failed(commandQueue)");
// Set Persistent memory only for AMD platform
cl_mem_flags inMemFlags = CL_MEM_READ_ONLY;
if (sampleArgs->isAmdPlatform()) {
inMemFlags |= CL_MEM_USE_PERSISTENT_MEM_AMD;
}
// Create buffer for input array
inBuf = clCreateBuffer(context, inMemFlags, length * sizeof(cl_uint), NULL,
&status);
CHECK_OPENCL_ERROR(status, "clCreateBuffer failed.(inBuf)");
// Set up data for input array
cl_event writeEvt;
status =
clEnqueueWriteBuffer(commandQueue, inBuf, CL_FALSE, 0,
length * sizeof(cl_uint), input, 0, NULL, &writeEvt);
CHECK_OPENCL_ERROR(status, "clEnqueueWriteBuffer(inBuf) failed..");
status = clFlush(commandQueue);
CHECK_OPENCL_ERROR(status, "clFlush(commandQueue) failed.");
counterOutBuf = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_uint),
NULL, &status);
CHECK_OPENCL_ERROR(status, "clCreateBuffer failed.(counterOutBuf).");
globalOutBuf = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_uint),
NULL, &status);
CHECK_OPENCL_ERROR(status, "clCreateBuffer failed.(globalOutBuf).");
// create a CL program using the kernel source
buildProgramData buildData;
buildData.kernelName = std::string("AtomicCounters_Kernels.cl");
buildData.devices = devices;
buildData.deviceId = sampleArgs->deviceId;
buildData.flagsStr = std::string("");
if (sampleArgs->isLoadBinaryEnabled()) {
buildData.binaryName = std::string(sampleArgs->loadBinary.c_str());
}
if (sampleArgs->isComplierFlagsSpecified()) {
buildData.flagsFileName = std::string(sampleArgs->flags.c_str());
}
retValue = buildOpenCLProgram(program, context, buildData);
CHECK_ERROR(retValue, SDK_SUCCESS, "buildOpenCLProgram() failed");
// ConstantBuffer bandwidth from single access
counterKernel = clCreateKernel(program, "atomicCounters", &status);
CHECK_OPENCL_ERROR(status, "clCreateKernel failed.(counterKernel).");
globalKernel = clCreateKernel(program, "globalAtomics", &status);
CHECK_OPENCL_ERROR(status, "clCreateKernel(globalKernel) failed.");
status = kernelInfoC.setKernelWorkGroupInfo(counterKernel,
devices[sampleArgs->deviceId]);
CHECK_OPENCL_ERROR(status, "kernelInfo.setKernelWorkGroupInfo failed");
status = kernelInfoG.setKernelWorkGroupInfo(globalKernel,
devices[sampleArgs->deviceId]);
CHECK_OPENCL_ERROR(status, "kernelInfo.setKernelWorkGroupInfo failed");
if (counterWorkGroupSize > kernelInfoC.kernelWorkGroupSize) {
if (!sampleArgs->quiet) {
std::cout << "Out of Resources!" << std::endl;
std::cout << "Group Size specified : " << counterWorkGroupSize
<< std::endl;
std::cout << "Max Group Size supported on the kernel(readKernel) : "
<< kernelInfoC.kernelWorkGroupSize << std::endl;
std::cout << "Falling back to " << kernelInfoC.kernelWorkGroupSize
<< std::endl;
}
counterWorkGroupSize = kernelInfoC.kernelWorkGroupSize;
}
if (globalWorkGroupSize > kernelInfoG.kernelWorkGroupSize) {
if (!sampleArgs->quiet) {
std::cout << "Out of Resources!" << std::endl;
std::cout << "Group Size specified : " << globalWorkGroupSize
<< std::endl;
std::cout << "Max Group Size supported on the kernel(writeKernel) : "
<< kernelInfoG.kernelWorkGroupSize << std::endl;
std::cout << "Falling back to " << kernelInfoG.kernelWorkGroupSize
<< std::endl;
}
globalWorkGroupSize = kernelInfoG.kernelWorkGroupSize;
}
// Wait for event and release event
status = waitForEventAndRelease(&writeEvt);
CHECK_OPENCL_ERROR(status, "waitForEventAndRelease(writeEvt) failed.");
return SDK_SUCCESS;
}
/**
* Process any relevant changes in the attached USB devices.
*
* Except for the first call, this is always running on the service thread.
*/
void USBProxyService::processChanges(void)
{
LogFlowThisFunc(("\n"));
/*
* Get the sorted list of USB devices.
*/
PUSBDEVICE pDevices = getDevices();
pDevices = sortDevices(pDevices);
// get a list of all running machines while we're outside the lock
// (getOpenedMachines requests higher priority locks)
SessionMachinesList llOpenedMachines;
mHost->parent()->getOpenedMachines(llOpenedMachines);
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/*
* Compare previous list with the new list of devices
* and merge in any changes while notifying Host.
*/
HostUSBDeviceList::iterator it = this->mDevices.begin();
while ( it != mDevices.end()
|| pDevices)
{
ComObjPtr<HostUSBDevice> pHostDevice;
if (it != mDevices.end())
pHostDevice = *it;
/*
* Assert that the object is still alive (we still reference it in
* the collection and we're the only one who calls uninit() on it.
*/
AutoCaller devCaller(pHostDevice.isNull() ? NULL : pHostDevice);
AssertComRC(devCaller.rc());
/*
* Lock the device object since we will read/write its
* properties. All Host callbacks also imply the object is locked.
*/
AutoWriteLock devLock(pHostDevice.isNull() ? NULL : pHostDevice
COMMA_LOCKVAL_SRC_POS);
/*
* Compare.
*/
int iDiff;
if (pHostDevice.isNull())
iDiff = 1;
else
{
if (!pDevices)
iDiff = -1;
else
iDiff = pHostDevice->compare(pDevices);
}
if (!iDiff)
{
/*
* The device still there, update the state and move on. The PUSBDEVICE
* structure is eaten by updateDeviceState / HostUSBDevice::updateState().
*/
PUSBDEVICE pCur = pDevices;
pDevices = pDevices->pNext;
pCur->pPrev = pCur->pNext = NULL;
bool fRunFilters = false;
SessionMachine *pIgnoreMachine = NULL;
devLock.release();
alock.release();
if (updateDeviceState(pHostDevice, pCur, &fRunFilters, &pIgnoreMachine))
deviceChanged(pHostDevice,
(fRunFilters ? &llOpenedMachines : NULL),
pIgnoreMachine);
alock.acquire();
it++;
}
else
{
if (iDiff > 0)
{
/*
* Head of pDevices was attached.
*/
PUSBDEVICE pNew = pDevices;
pDevices = pDevices->pNext;
pNew->pPrev = pNew->pNext = NULL;
ComObjPtr<HostUSBDevice> NewObj;
NewObj.createObject();
NewObj->init(pNew, this);
Log(("USBProxyService::processChanges: attached %p {%s} %s / %p:{.idVendor=%#06x, .idProduct=%#06x, .pszProduct=\"%s\", .pszManufacturer=\"%s\"}\n",
(HostUSBDevice *)NewObj,
NewObj->getName().c_str(),
NewObj->getStateName(),
pNew,
pNew->idVendor,
pNew->idProduct,
pNew->pszProduct,
pNew->pszManufacturer));
mDevices.insert(it, NewObj);
devLock.release();
alock.release();
deviceAdded(NewObj, llOpenedMachines, pNew);
alock.acquire();
}
else
{
/*
* Check if the device was actually detached or logically detached
* as the result of a re-enumeration.
*/
if (!pHostDevice->wasActuallyDetached())
it++;
else
{
it = mDevices.erase(it);
devLock.release();
alock.release();
deviceRemoved(pHostDevice);
Log(("USBProxyService::processChanges: detached %p {%s}\n",
(HostUSBDevice *)pHostDevice,
pHostDevice->getName().c_str()));
/* from now on, the object is no more valid,
* uninitialize to avoid abuse */
devCaller.release();
pHostDevice->uninit();
alock.acquire();
}
}
}
} /* while */
LogFlowThisFunc(("returns void\n"));
}
const QHash<QString, QString> WASAPISystem::getOutputDevices() {
return getDevices(eRender);
}
