BOOL OpenContext::GetConfigDescriptor(LPUKWD_GET_CONFIG_DESC_INFO lpConfigInfo, LPDWORD lpSize) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpConfigInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } UserBuffer<LPVOID> descriptorBuf(UBA_WRITE, lpConfigInfo->lpDescriptorBuffer, lpConfigInfo->dwDescriptorBufferSize); if (!descriptorBuf.Valid()) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } BOOL status = FALSE; if (lpConfigInfo->dwConfigIndex == UKWD_ACTIVE_CONFIGURATION) { status = dev->GetActiveConfigDescriptor(descriptorBuf, lpSize); } else { status = dev->GetConfigDescriptor(lpConfigInfo->dwConfigIndex, descriptorBuf, lpSize); } if (!status) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::GetConfigDescriptor() - ") TEXT("failed to retrieve device 0x%08x config descriptor idx %d\r\n"), lpConfigInfo->lpDevice, lpConfigInfo->dwConfigIndex)); return FALSE; } descriptorBuf.Flush(); return TRUE; }
BOOL OpenContext::SetActiveConfigValue(LPUKWD_SET_ACTIVE_CONFIG_VALUE_INFO lpConfigValueInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpConfigValueInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } if (dev->AnyInterfacesClaimed()) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::SetActiveConfigValue() - ") TEXT("attempting to set configuration on device 0x%08x with claimed interfaces\r\n"), lpConfigValueInfo->lpDevice)); SetLastError(ERROR_BUSY); return FALSE; } /* WARNING: THIS IS NOT SUPPORTED PROPERLY YET!! * The driver has a prototype implementation for IOCTL_UKW_SET_ACTIVE_CONFIG_VALUE, * which manually sends the SET_CONFIGURATION control transfer. This, however, then * causes WinCE to become out-of-sync with the actual device configuration (most likely * leading to all sorts of fun and games!). Currently, the driver therefore only send * the control transfer if the requested configuration is already active. */ UCHAR cv = 0; GetActiveConfigValue(lpConfigValueInfo->lpDevice, &cv); if (cv != lpConfigValueInfo->value) { SetLastError(ERROR_NOT_SUPPORTED); return FALSE; } return dev->SetActiveConfigValue(lpConfigValueInfo->value); }
//added by Cristian.Guef int NodesRepository::Add(const DevicePtr& node) { if (!nodesByMAC.insert(NodesByMACT::value_type(node->Mac(), node)).second) { LOG_WARN("Same MAC:" << node->Mac().ToString() << "was detected (will be ignored)!"); return 0; } return 1; }
BOOL OpenContext::StartBulkTransfer(LPUKWD_BULK_TRANSFER_INFO lpTransferInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpTransferInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Interface can't be used if device has closed if (dev->Closed()) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Find the interface for this transfer DWORD dwInterface; if (!dev->FindInterface(lpTransferInfo->Endpoint, dwInterface)) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - ") TEXT("failed to find interface for endpoint %d on device 0x%08x\r\n"), lpTransferInfo->Endpoint, lpTransferInfo->lpDevice)); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // See if it's already been claimed if (!dev->InterfaceClaimed(dwInterface, this)) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - ") TEXT("using interface %d on device 0x%08x without claiming\r\n"), dwInterface, lpTransferInfo->lpDevice)); if (!dev->ClaimInterface(dwInterface, this)) { return FALSE; } } TRANSFERLIFETIME_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() on ep %x, flag 0x%08x and size %d\r\n"), lpTransferInfo->Endpoint, lpTransferInfo->dwFlags, lpTransferInfo->dwDataBufferSize)); // Construct and start the bulk transfer BulkTransfer* bt = new (std::nothrow) BulkTransfer( this, dev, dwInterface, lpTransferInfo); if (!bt) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - failed to create bulk transfer, aborting\r\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } BOOL ret = bt->Start(); mTransferList->PutTransfer(bt); bt = NULL; if (!ret) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - failed to start bulk transfer %d\r\n"), GetLastError())); return FALSE; } // Ownership of ct has passed to the transfer callback return TRUE; }
BOOL OpenContext::DetachKernelDriverForInterface(LPUKWD_INTERFACE_INFO lpInterfaceInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpInterfaceInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } return dev->DetachKernelDriverForInterface(lpInterfaceInfo->dwInterface); }
BOOL OpenContext::ReenumerateDevice(UKWD_USB_DEVICE DeviceIdentifier) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), DeviceIdentifier); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } return dev->Reenumerate(); }
BOOL OpenContext::GetActiveConfigValue(UKWD_USB_DEVICE DeviceIdentifier, PUCHAR pConfigurationValue) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), DeviceIdentifier); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } return dev->GetActiveConfigValue(pConfigurationValue); }
StaticMesh::StaticMesh(DevicePtr dptr, const MeshData& mesh_data) : _triangle_buffer(dptr, mesh_data.triangles().size()), _vertex_buffer(dptr, mesh_data.vertices().size()), _indirect_data(mesh_data.triangles().size() * 3, 1), _radius(mesh_data.radius()) { CmdBufferRecorder recorder(dptr->create_disposable_cmd_buffer()); Mapping::stage(_triangle_buffer, recorder, mesh_data.triangles().data()); Mapping::stage(_vertex_buffer, recorder, mesh_data.vertices().data()); dptr->graphic_queue().submit<SyncSubmit>(RecordedCmdBuffer(std::move(recorder))); }
static vk::Buffer create_buffer(DevicePtr dptr, usize byte_size, vk::BufferUsageFlags usage) { y_debug_assert(byte_size); if(usage & vk::BufferUsageFlagBits::eUniformBuffer) { if(byte_size > dptr->vk_limits().maxUniformBufferRange) { y_fatal("Uniform buffer size exceeds maxUniformBufferRange (%).", dptr->vk_limits().maxUniformBufferRange); } } return dptr->vk_device().createBuffer(vk::BufferCreateInfo() .setSize(byte_size) .setUsage(usage) .setSharingMode(vk::SharingMode::eExclusive) ); }
// Called with the mutex lock already held BOOL OpenContext::PutDevice(UKWD_USB_DEVICE DeviceIdentifier) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), DeviceIdentifier); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } mOpenDevices.erase(dev.Get()); // Put for the reference in mOpenDevices mDevice->GetDeviceList()->PutDevice(dev.Get()); return TRUE; }
PlayerBehavior::CONTROLL PlayerBehavior::makeControll( ) { PlayerBehavior::CONTROLL controll; if ( _controll ) { // 自分で動かす DevicePtr device = Device::getTask( ); unsigned char button = device->getButton( ); CameraPtr camera = Camera::getTask( ); PlayerCameraPtr p_camera = std::dynamic_pointer_cast< PlayerCamera >( camera ); Vector move_vec = p_camera->getConvertDeviceVec( ); Character::STATUS status = _parent->getStatus( ); move_vec = move_vec.normalize( ) * status.speed;//プレイヤーの進行ベクトル controll.move = move_vec; if ( button & BUTTON_D ) { controll.action = CONTROLL::DEATHBLOW; } else if ( button & BUTTON_A ) { controll.action = CONTROLL::ATTACK; } else { controll.action = CONTROLL::NONE; } } else { // ネットから動かす ClientPtr client = Client::getTask( ); CLIENTDATA data = client->getClientData( ); Vector target; target.x = data.player[ _player_id ].x; target.y = data.player[ _player_id ].y; Vector vec = target - _parent->getPos( ); Character::STATUS status = _parent->getStatus( ); if ( vec.getLength( ) > status.speed * 2 ) { vec = vec.normalize( ) * status.speed; controll.move = vec; } switch ( data.player[ _player_id ].action ) { case ACTION_NONE: controll.action = CONTROLL::NONE; break; case ACTION_ATTACK: controll.action = CONTROLL::ATTACK; break; case ACTION_DEATHBLOW: controll.action = CONTROLL::MUSTDEATHBLOW; break; } } return controll; }
// Checks that device is valid and is open // by this context. BOOL OpenContext::Validate(DevicePtr& device) { if (!device.Valid()) return FALSE; PtrArray<UsbDevice>::iterator it = mOpenDevices.find(device.Get()); if (it == mOpenDevices.end()) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::Validate") TEXT(" - failed to find device in this context for identifier 0x%08x\r\n"), device->GetIdentifier())); return FALSE; } return TRUE; }
static vk::DescriptorSet create_descriptor_set(DevicePtr dptr, vk::DescriptorPool pool, vk::DescriptorSetLayout layout) { return dptr->vk_device().allocateDescriptorSets(vk::DescriptorSetAllocateInfo() .setDescriptorPool(pool) .setDescriptorSetCount(1) .setPSetLayouts(&layout) ).front(); }
void BodyStateViewImpl::updateDeviceStates(DevicePtr device, int rowIndex) { if(currentBody){ StateItem* item = static_cast<StateItem*>(stateTreeWidget.topLevelItem(rowIndex)); int size = device->stateSize(); buf.resize(size); device->writeState(&buf.front()); int i; for(i=0; i < size; ++i){ item->setText(i + 1, QString::number(buf[i], 'f', 2)); } for( ; i < item->lastNumValidColumns; ++i){ item->setText(i + 1, ""); } item->lastNumValidColumns = size; } }
//----------------------------------------------------------------------------- GpuPtr Helper::getGpu(int index) { // Check it against selection criteria. pair_int gpuBlock = selectDeviceAndBlock(index); if (-1 == gpuBlock.first) return GpuPtr(); scoped_lock lock(mutex); // First check to see if this GPU device has been initialized. DevicePtr device; DevicelPtrMap::iterator dit = devPtrMap.find(gpuBlock.first); if (dit == devPtrMap.end()) { device.reset(new Device(gpuBlock.first)); // Double check to make sure our device is OK if (-1 == device->ID()) return GpuPtr(); devPtrMap.insert(std::make_pair(gpuBlock.first, device)); } else { device = dit->second; // Make sure we activate this per-thread. device->setDevice(); } // Now that we have a device, get the block implementation handle. GpuPtr impl; GpuPtrMap::iterator it = gpuPtrMap.find(index); if (it == gpuPtrMap.end()) { impl.reset(new Gpu(device)); gpuPtrMap.insert(std::make_pair(index, impl)); } else { impl = it->second; } if (!atExitRegistered) { atexit(Helper::destroy); atExitRegistered = true; } return impl; }
static std::tuple<vk::Buffer, DeviceMemory> alloc_buffer(DevicePtr dptr, usize buffer_size, vk::BufferUsageFlags usage, MemoryType type) { y_debug_assert(buffer_size); auto buffer = create_buffer(dptr, buffer_size, usage); auto memory = dptr->allocator().alloc(buffer, type); bind_buffer_memory(dptr, buffer, memory); return {buffer, std::move(memory)}; }
DevicePtr<cuda::Transformation3D> Transformation3D::CopyToGpu(DevicePtr<cuda::Transformation3D> const gpu_ptr) const { gpu_ptr.Construct(fTranslation[0], fTranslation[1], fTranslation[2], fRotation[0], fRotation[1], fRotation[2], fRotation[3], fRotation[4], fRotation[5], fRotation[6], fRotation[7], fRotation[8]); CudaAssertError(); return gpu_ptr; }
static vk::ShaderModule create_shader_module(DevicePtr dptr, const SpirVData& data) { if(data.is_empty()) { return vk::ShaderModule(); } return dptr->vk_device().createShaderModule(vk::ShaderModuleCreateInfo() .setCodeSize(data.size()) .setPCode(data.data()) ); }
DevicePtr<cuda::LogicalVolume> LogicalVolume::CopyToGpu( DevicePtr<cuda::VUnplacedVolume> const unplaced_vol, DevicePtr<cuda::Vector<CudaDaughter_t>> daughters, DevicePtr<cuda::LogicalVolume> const gpu_ptr) const { gpu_ptr.Construct( unplaced_vol, daughters ); CudaAssertError(); return gpu_ptr; }
BOOL OpenContext::SetAltSetting(LPUKWD_SET_ALTSETTING_INFO lpSetAltSettingInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpSetAltSettingInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } if (!dev->InterfaceClaimed(lpSetAltSettingInfo->dwInterface, this)) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::SetAltSetting() - ") TEXT("using interface %d on device 0x%08x without claiming\r\n"), lpSetAltSettingInfo->dwInterface, lpSetAltSettingInfo->lpDevice)); if (!dev->ClaimInterface(lpSetAltSettingInfo->dwInterface, this)) { return FALSE; } } return dev->SetAltSetting(lpSetAltSettingInfo->dwInterface, lpSetAltSettingInfo->dwAlternateSetting); }
void BoxClass::TruncateBoxList (Box dev) { STUB; return; #if 0 if (!boxList) return; if (boxList == dev) { boxList = NULL; return; } DevicePtr d = boxList ; while (d->GetNext() && d->GetNext() != dev) { d = d->GetNext(); } if (d->GetNext()) { d -> SetNext(NULL); } #endif }
void P44VdcHost::identifyHandler(JsonCommPtr aJsonComm, DevicePtr aDevice) { MainLoop::currentMainLoop().cancelExecutionTicket(learnIdentifyTicket); if (aDevice) { sendCfgApiResponse(aJsonComm, JsonObject::newString(aDevice->getDsUid().getString()), ErrorPtr()); // end monitor mode setUserActionMonitor(NULL); } else { sendCfgApiResponse(aJsonComm, JsonObjectPtr(), Error::err<P44VdcError>(408, "identify timeout")); setUserActionMonitor(NULL); } learnIdentifyRequest.reset(); }
DepthCameraPtr TintinCDKCameraFactory::getDepthCamera(DevicePtr device) { if(device->interfaceID() == Device::USB) { USBDevice &d = (USBDevice &)*device; if(d.vendorID() == TINTIN_CDK_VENDOR_ID && (d.productID() == TINTIN_CDK_PRODUCT_BULK || d.productID() == TINTIN_CDK_PRODUCT_UVC)) { return DepthCameraPtr(new TintinCDKCamera(device)); } } return 0; }
void ColladaBodyLoaderImpl::setSensor(DaeNode* extNode, Link* link, Body& body) { DaeLink* nodeLink = static_cast<DaeLink*>(extNode); DaeResultSensors* sensors = parser->findSensor(nodeLink->id); if (sensors->size() <= 0) { return; } // ForceSensor--------->force6d // GyroSensor---------->no type(empty string) // AccelerrationSensor->imu(unit sensor) // VisionSensor-------->pin-hole-camera for (DaeResultSensors::iterator iters = sensors->begin(); iters != sensors->end(); iters++) { DaeSensor* sensor = *iters; DevicePtr device = createSensor(sensor); device->setLink(link); device->setLocalTranslation(extNode->transform.translate + sensor->transform.translate); device->setLocalRotation (extNode->transform.rotate.matrix() * sensor->transform.rotate.matrix()); body.addDevice(device); } }
DevicePtr ColladaBodyLoaderImpl::createSensor(DaeSensor* sensor) { DevicePtr device; if (sensor->type.size() <= 0) { device = new RateGyroSensor; } else if (iequals(sensor->type, "base_force6d")) { device = new ForceSensor; } else if (iequals(sensor->type, "base_imu")) { device = new AccelerationSensor; } else if (iequals(sensor->type, "base_pinhole_camera")) { device = new Camera; Camera* camera = static_cast<Camera*>(device.get()); camera->setResolution(sensor->imageDimensions[0], sensor->imageDimensions[1]); camera->setNearDistance(sensor->focalLength); camera->setFieldOfView (sensor->focalLength); } else { throwException((format(_("invalid sensor-type:%1%")) % sensor->type).str()); } return device; }
static vk::DescriptorPool create_descriptor_pool(DevicePtr dptr, const std::unordered_map<vk::DescriptorType, u32>& binding_counts) { auto sizes = core::vector_with_capacity<vk::DescriptorPoolSize>(binding_counts.size()); std::transform(binding_counts.begin(), binding_counts.end(), std::back_inserter(sizes), [](const auto& count) { return vk::DescriptorPoolSize() .setType(count.first) .setDescriptorCount(count.second) ; }); return dptr->vk_device().createDescriptorPool(vk::DescriptorPoolCreateInfo() .setPoolSizeCount(sizes.size()) .setPPoolSizes(sizes.begin()) .setMaxSets(1) ); }
/** * \brief Construct a camera from a camera description * * \param name Name of the camera * \return Camera with that name */ CameraPtr SxCameraLocator::getCamera0(const DeviceName& name) { std::string sname = name.unitname(); debug(LOG_DEBUG, DEBUG_LOG, 0, "analyzing '%s'", sname.c_str()); // parse the name string int busnumber = 0, deviceaddress = 0; sxparse(sname, busnumber, deviceaddress); debug(LOG_DEBUG, DEBUG_LOG, 0, "looking for busnumber=%d, deviceaddress=%d", busnumber, deviceaddress); // find the device with this bus number and address std::vector<DevicePtr> d = context.devices(); std::vector<DevicePtr>::const_iterator i; for (i = d.begin(); i != d.end(); i++) { DevicePtr dptr = (*i); if ((dptr->getBusNumber() == busnumber) && (dptr->getDeviceAddress() == deviceaddress)) { debug(LOG_DEBUG, DEBUG_LOG, 0, "found matching device"); dptr->open(); return CameraPtr(new SxCamera(dptr)); } } throw SxError("cannot create a camera from a name"); }
DescriptorSet::DescriptorSet(DevicePtr dptr, core::ArrayView<Binding> bindings) : DescriptorSetBase(dptr) { if(!bindings.is_empty()) { auto layout_bindings = core::vector_with_capacity<vk::DescriptorSetLayoutBinding>(bindings.size()); std::unordered_map<vk::DescriptorType, u32> binding_counts; for(const auto& binding : bindings) { layout_bindings << binding.descriptor_set_layout_binding(layout_bindings.size()); ++binding_counts[binding.vk_descriptor_type()]; } auto layout = dptr->create_descriptor_set_layout(layout_bindings); _pool = create_descriptor_pool(dptr, binding_counts); _set = create_descriptor_set(dptr, _pool, layout); update_sets(dptr, _set, layout_bindings, bindings); } }
static void update_sets(DevicePtr dptr, vk::DescriptorSet set, const core::Vector<vk::DescriptorSetLayoutBinding>& /*layout_binding*/, const core::ArrayView<Binding>& bindings) { auto writes = core::vector_with_capacity<vk::WriteDescriptorSet>(bindings.size()); for(const auto& binding : bindings) { auto w = vk::WriteDescriptorSet() .setDstSet(set) .setDstBinding(u32(writes.size())) .setDstArrayElement(0) .setDescriptorCount(1) .setDescriptorType(binding.vk_descriptor_type()) ; if(binding.is_buffer()) { w.setPBufferInfo(&binding.descriptor_info().buffer); } else if(binding.is_image()) { w.setPImageInfo(&binding.descriptor_info().image); } else { y_fatal("Unknown descriptor type."); } writes << w; } dptr->vk_device().updateDescriptorSets(u32(writes.size()), writes.begin(), 0, nullptr); }
void VRMLBodyLoaderImpl::readDeviceNode(LinkInfo& iLink, VRMLProtoInstance* deviceNode, const Affine3& T) { const string& typeName = deviceNode->proto->protoName; if(isVerbose) putMessage(typeName + " node " + deviceNode->defName); DeviceFactoryMap::iterator p = deviceFactories.find(typeName); if(p == deviceFactories.end()){ os() << str(format("Sensor type %1% is not supported.\n") % typeName) << endl; } else { DeviceFactory& factory = p->second; DevicePtr device = factory(deviceNode); if(device){ device->setLink(iLink.link); const Matrix3 RsT = iLink.link->Rs(); device->setLocalTranslation(RsT * (T * device->localTranslation())); device->setLocalRotation(RsT * (T.linear() * device->localRotation())); body->addDevice(device); } } }