std::string VulkanBase::getWindowTitle() {
std::string device(deviceProperties.deviceName);
std::string windowTitle;
windowTitle = title + " - " + device + " - " + std::to_string(frameCounter) + " fps";
return windowTitle;
}
void diskiing_device::device_start()
{
m_rom = device().machine().root_device().memregion(this->subtag(DISKII_ROM_REGION).c_str())->base();
}
void dio16_98603b_device::device_reset()
{
m_rom = device().machine().root_device().memregion(this->subtag(HP98603B_ROM_REGION).c_str())->base();
m_dio->install_memory(0x100000, 0x1fffff, read16_delegate(FUNC(dio16_98603b_device::rom_r), this),
write16_delegate(FUNC(dio16_98603b_device::rom_w), this));
}
bool SharePlugin::receivePackage(const NetworkPackage& np)
{
/*
//TODO: Write a test like this
if (np.type() == PACKAGE_TYPE_PING) {
qCDebug(KDECONNECT_PLUGIN_SHARE) << "sending file" << (QDesktopServices::storageLocation(QDesktopServices::HomeLocation) + "/.bashrc");
NetworkPackage out(PACKAGE_TYPE_SHARE_REQUEST);
out.set("filename", mDestinationDir + "itworks.txt");
AutoClosingQFile* file = new AutoClosingQFile(QDesktopServices::storageLocation(QDesktopServices::HomeLocation) + "/.bashrc"); //Test file to transfer
out.setPayload(file, file->size());
device()->sendPackage(out);
return true;
}
*/
qCDebug(KDECONNECT_PLUGIN_SHARE) << "File transfer";
if (np.hasPayload()) {
//qCDebug(KDECONNECT_PLUGIN_SHARE) << "receiving file";
const QString filename = np.get<QString>(QStringLiteral("filename"), QString::number(QDateTime::currentMSecsSinceEpoch()));
const QUrl dir = destinationDir().adjusted(QUrl::StripTrailingSlash);
QUrl destination(dir.toString() + '/' + filename);
if (destination.isLocalFile() && QFile::exists(destination.toLocalFile())) {
destination = QUrl(dir.toString() + '/' + KIO::suggestName(dir, filename));
}
FileTransferJob* job = np.createPayloadTransferJob(destination);
job->setOriginName(device()->name() + ": " + filename);
connect(job, &KJob::result, this, &SharePlugin::finished);
KIO::getJobTracker()->registerJob(job);
job->start();
} else if (np.has(QStringLiteral("text"))) {
QString text = np.get<QString>(QStringLiteral("text"));
if (!QStandardPaths::findExecutable(QStringLiteral("kate")).isEmpty()) {
QProcess* proc = new QProcess();
connect(proc, SIGNAL(finished(int)), proc, SLOT(deleteLater()));
proc->start(QStringLiteral("kate"), QStringList(QStringLiteral("--stdin")));
proc->write(text.toUtf8());
proc->closeWriteChannel();
} else {
QTemporaryFile tmpFile;
tmpFile.setAutoRemove(false);
tmpFile.open();
tmpFile.write(text.toUtf8());
tmpFile.close();
const QUrl url = QUrl::fromLocalFile(tmpFile.fileName());
Q_EMIT shareReceived(url);
QDesktopServices::openUrl(url);
}
} else if (np.has(QStringLiteral("url"))) {
QUrl url = QUrl::fromEncoded(np.get<QByteArray>(QStringLiteral("url")));
QDesktopServices::openUrl(url);
Q_EMIT shareReceived(url);
} else {
qCDebug(KDECONNECT_PLUGIN_SHARE) << "Error: Nothing attached!";
}
return true;
}
int main()
{
//
// Create a domain from file
//
viennamini::MeshTriangular2DType mesh;
viennamini::SegmentationTriangular2DType segments(mesh);
viennamini::StorageType storage;
try
{
viennagrid::io::netgen_reader my_reader;
// my_reader(mesh, segments, "../external/ViennaDeviceCollection/nin2d/nin2d.mesh");
my_reader(mesh, segments, "/home/weinbub/git/ViennaMini/external/ViennaDeviceCollection/nin2d/nin2d.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
//
// scale to nanometer
//
viennagrid::scale(mesh, 1e-9);
//
// Prepare material library
//
viennamini::MatLibPugixmlType matlib;
matlib.load("/home/weinbub/git/ViennaMini/external/ViennaMaterials/database/materials.xml");
//
// Create a device and a config object
//
viennamini::DeviceTriangular2DType device(mesh, segments, storage);
viennamini::config config;
//
// Prepare device, i.e., assign doping and segment roles,
// e.g., oxide, semiconductor, contact
//
prepare(device);
//
// Assign contact values
//
prepare_boundary_conditions(config);
//
// Set simulation parameters
//
config.temperature() = 300;
config.damping() = 1.0;
config.linear_breaktol() = 1.0E-13;
config.linear_iterations() = 700;
config.nonlinear_iterations() = 100;
config.nonlinear_breaktol() = 1.0E-3;
config.initial_guess_smoothing_iterations() = 4;
//
// Create a simulator object
//
viennamini::SimulatorTriangular2DType sim(device, matlib, config);
//
// Run the simulation
//
sim();
// Write results to vtk files
sim.write_result("nin2d");
std::cout << "********************************************" << std::endl;
std::cout << "* NIN2D simulation finished successfully! *" << std::endl;
std::cout << "********************************************" << std::endl;
return EXIT_SUCCESS;
}
void Event::reset() { EXPECT(vkResetEvent(device(), handle()) == VK_SUCCESS); }
void DescriptorPool::reset() {
EXPECT(vkResetDescriptorPool(device(), handle(), 0) == VK_SUCCESS);
}
int
main(void)
{
//float a = 23456.0f;
float a = 3.f;
// test the poclu's half conversion functions
printf("through conversion: %.0f\n",
poclu_cl_half_to_float(poclu_float_to_cl_half(42.0f)));
try {
std::vector<cl::Platform> platformList;
// Pick platform
cl::Platform::get(&platformList);
// Pick first platform
cl_context_properties cprops[] = {
CL_CONTEXT_PLATFORM, (cl_context_properties)(platformList[0])(), 0};
cl::Context context(CL_DEVICE_TYPE_GPU, cprops);
// Query the set of devices attched to the context
std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
assert (devices.size() == 1);
cl::Device device = devices.at(0);
assert (strncmp(device.getInfo<CL_DEVICE_NAME>().c_str(), "ttasim", 6)==0 );
a = poclu_bswap_cl_float (device(), a);
// Create and program from source
cl::Program::Sources sources(1, std::make_pair(kernelSourceCode, 0));
cl::Program program(context, sources);
// Build program
program.build(devices);
// Create kernel object
cl::Kernel kernel(program, "test_kernel");
// Set kernel args
kernel.setArg(0, a);
// Create command queue
cl::CommandQueue queue(context, devices[0], CL_QUEUE_PROFILING_ENABLE);
cl::Event enqEvent;
// Do the work
queue.enqueueNDRangeKernel(
kernel,
cl::NullRange,
cl::NDRange(8),
cl::NullRange,
NULL, &enqEvent);
queue.finish();
assert (enqEvent.getInfo<CL_EVENT_COMMAND_EXECUTION_STATUS>() == CL_COMPLETE);
assert (
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_QUEUED>() <=
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_SUBMIT>());
assert (
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_SUBMIT>() <=
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_START>());
assert (
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_START>() <
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_END>());
#if 0
std::cerr << "exec time: "
<< enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_END>() -
enqEvent.getProfilingInfo<CL_PROFILING_COMMAND_START>() << std::endl;
#endif
}
catch (cl::Error err) {
std::cerr
<< "ERROR: "
<< err.what()
<< "("
<< err.err()
<< ")"
<< std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
SkBitmap store;
store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
store.allocPixels();
SkDevice device(store);
NotificationCounter notificationCounter;
SkDeferredCanvas canvas(&device);
canvas.setNotificationClient(¬ificationCounter);
const int imageCount = 2;
SkBitmap sourceImages[imageCount];
for (int i = 0; i < imageCount; i++)
{
sourceImages[i].setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
sourceImages[i].allocPixels();
}
size_t bitmapSize = sourceImages[0].getSize();
canvas.drawBitmap(sourceImages[0], 0, 0, NULL);
REPORTER_ASSERT(reporter, 1 == notificationCounter.fStorageAllocatedChangedCount);
// stored bitmap + drawBitmap command
REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() > bitmapSize);
// verify that nothing can be freed at this point
REPORTER_ASSERT(reporter, 0 == canvas.freeMemoryIfPossible(~0U));
// verify that flush leaves image in cache
REPORTER_ASSERT(reporter, 0 == notificationCounter.fFlushedDrawCommandsCount);
REPORTER_ASSERT(reporter, 0 == notificationCounter.fPrepareForDrawCount);
canvas.flush();
REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
REPORTER_ASSERT(reporter, 1 == notificationCounter.fPrepareForDrawCount);
REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() >= bitmapSize);
// verify that after a flush, cached image can be freed
REPORTER_ASSERT(reporter, canvas.freeMemoryIfPossible(~0U) >= bitmapSize);
// Verify that caching works for avoiding multiple copies of the same bitmap
canvas.drawBitmap(sourceImages[0], 0, 0, NULL);
REPORTER_ASSERT(reporter, 2 == notificationCounter.fStorageAllocatedChangedCount);
canvas.drawBitmap(sourceImages[0], 0, 0, NULL);
REPORTER_ASSERT(reporter, 2 == notificationCounter.fStorageAllocatedChangedCount);
REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() < 2 * bitmapSize);
// Verify partial eviction based on bytesToFree
canvas.drawBitmap(sourceImages[1], 0, 0, NULL);
REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
canvas.flush();
REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() > 2 * bitmapSize);
size_t bytesFreed = canvas.freeMemoryIfPossible(1);
REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
REPORTER_ASSERT(reporter, bytesFreed >= bitmapSize);
REPORTER_ASSERT(reporter, bytesFreed < 2*bitmapSize);
// Verifiy that partial purge works, image zero is in cache but not reffed by
// a pending draw, while image 1 is locked-in.
canvas.freeMemoryIfPossible(~0U);
REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
canvas.drawBitmap(sourceImages[0], 0, 0, NULL);
canvas.flush();
canvas.drawBitmap(sourceImages[1], 0, 0, NULL);
bytesFreed = canvas.freeMemoryIfPossible(~0U);
// only one bitmap should have been freed.
REPORTER_ASSERT(reporter, bytesFreed >= bitmapSize);
REPORTER_ASSERT(reporter, bytesFreed < 2*bitmapSize);
// Clear for next test
canvas.flush();
canvas.freeMemoryIfPossible(~0U);
REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() < bitmapSize);
// Verify the image cache is sensitive to genID bumps
canvas.drawBitmap(sourceImages[1], 0, 0, NULL);
sourceImages[1].notifyPixelsChanged();
canvas.drawBitmap(sourceImages[1], 0, 0, NULL);
REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() > 2*bitmapSize);
// Verify that nothing in this test caused commands to be skipped
REPORTER_ASSERT(reporter, 0 == notificationCounter.fSkippedPendingDrawCommandsCount);
}
/** @brief Blocks until all kernels on the device have finished
*/
void finish()
{
clFinish(device().queue().get());
}
void device_vcs_cart_interface::ram_alloc(UINT32 size)
{
m_ram.resize(size);
device().save_item(NAME(m_ram));
}
/** @brief Flush the device command queue, i.e. wait until all kernels in the command queue have started.
*/
void flush()
{
clFlush(device().queue().get());
}
void device_a2eauxslot_card_interface::set_a2eauxslot_device()
{
m_a2eauxslot = dynamic_cast<a2eauxslot_device *>(device().machine().device(m_a2eauxslot_tag));
m_a2eauxslot->add_a2eauxslot_card(this);
}
void EWingInput::feedBack(quint32 input, quint32 channel, uchar value)
{
EWing* ewing = device(input);
if (ewing != NULL)
ewing->feedBack(channel, value);
}
DeviceMemory::~DeviceMemory() {
if (initialized())
vkFreeMemory(device(), handle(), NULL);
}
static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
SkBitmap store;
SkRect fullRect;
fullRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(gWidth),
SkIntToScalar(gHeight));
SkRect partialRect;
partialRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0),
SkIntToScalar(1), SkIntToScalar(1));
create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice device(store);
SkDeferredCanvas canvas(&device);
// verify that frame is intially fresh
REPORTER_ASSERT(reporter, canvas.isFreshFrame());
// no clearing op since last call to isFreshFrame -> not fresh
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
// Verify that clear triggers a fresh frame
canvas.clear(0x00000000);
REPORTER_ASSERT(reporter, canvas.isFreshFrame());
// Verify that clear with saved state triggers a fresh frame
canvas.save(SkCanvas::kMatrixClip_SaveFlag);
canvas.clear(0x00000000);
canvas.restore();
REPORTER_ASSERT(reporter, canvas.isFreshFrame());
// Verify that clear within a layer does NOT trigger a fresh frame
canvas.saveLayer(NULL, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
canvas.clear(0x00000000);
canvas.restore();
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
// Verify that a clear with clipping triggers a fresh frame
// (clear is not affected by clipping)
canvas.save(SkCanvas::kMatrixClip_SaveFlag);
canvas.clipRect(partialRect, SkRegion::kIntersect_Op, false);
canvas.clear(0x00000000);
canvas.restore();
REPORTER_ASSERT(reporter, canvas.isFreshFrame());
// Verify that full frame rects with different forms of opaque paint
// trigger frames to be marked as fresh
{
SkPaint paint;
paint.setStyle( SkPaint::kFill_Style );
paint.setAlpha( 255 );
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, canvas.isFreshFrame());
}
{
SkPaint paint;
paint.setStyle( SkPaint::kFill_Style );
paint.setAlpha( 255 );
paint.setXfermodeMode(SkXfermode::kSrcIn_Mode);
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
{
SkPaint paint;
paint.setStyle( SkPaint::kFill_Style );
SkBitmap bmp;
create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
bmp.setIsOpaque(true);
SkShader* shader = SkShader::CreateBitmapShader(bmp,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
paint.setShader(shader)->unref();
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, canvas.isFreshFrame());
}
// Verify that full frame rects with different forms of non-opaque paint
// do not trigger frames to be marked as fresh
{
SkPaint paint;
paint.setStyle( SkPaint::kFill_Style );
paint.setAlpha( 254 );
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
{
SkPaint paint;
paint.setStyle( SkPaint::kFill_Style );
SkBitmap bmp;
create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
bmp.setIsOpaque(false);
SkShader* shader = SkShader::CreateBitmapShader(bmp,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
paint.setShader(shader)->unref();
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
// Verify that incomplete coverage does not trigger a fresh frame
{
SkPaint paint;
paint.setStyle(SkPaint::kFill_Style);
paint.setAlpha(255);
canvas.drawRect(partialRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
// Verify that incomplete coverage due to clipping does not trigger a fresh
// frame
{
canvas.save(SkCanvas::kMatrixClip_SaveFlag);
canvas.clipRect(partialRect, SkRegion::kIntersect_Op, false);
SkPaint paint;
paint.setStyle(SkPaint::kFill_Style);
paint.setAlpha(255);
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
// Verify that stroked rect does not trigger a fresh frame
{
SkPaint paint;
paint.setStyle( SkPaint::kStroke_Style );
paint.setAlpha( 255 );
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
// Verify kSrcMode triggers a fresh frame even with transparent color
{
SkPaint paint;
paint.setStyle( SkPaint::kFill_Style );
paint.setAlpha( 100 );
paint.setXfermodeMode(SkXfermode::kSrc_Mode);
canvas.drawRect(fullRect, paint);
REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
}
}
void DeviceMemory::unmap() const { vkUnmapMemory(device(), handle()); }
/*!
Returns true if this QDriveInfo object refers to the same drive or volume
as the \a other; otherwise returns false.
Note that the result of comparing two invalid QDriveInfo objects is always positive.
\sa operator!=()
*/
bool QDriveInfo::operator==(const QDriveInfo &other) const
{
if (d == other.d)
return true;
return device() == other.device();
}
void Image::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset) {
EXPECT(vkBindImageMemory(device(), handle(), mem.handle(), mem_offset) ==
VK_SUCCESS);
}
bool QGLContext::chooseContext(const QGLContext* shareContext)
{
Q_D(QGLContext);
// Validate the device.
if (!device())
return false;
int devType = device()->devType();
if (devType != QInternal::Pixmap && devType != QInternal::Image && devType != QInternal::Widget) {
qWarning("QGLContext::chooseContext(): Cannot create QGLContext's for paint device type %d", devType);
return false;
}
// Get the display and initialize it.
d->eglContext = new QEglContext();
d->ownsEglContext = true;
d->eglContext->setApi(QEgl::OpenGL);
// Construct the configuration we need for this surface.
QEglProperties configProps;
qt_eglproperties_set_glformat(configProps, d->glFormat);
configProps.setDeviceType(devType);
configProps.setPaintDeviceFormat(device());
configProps.setRenderableType(QEgl::OpenGL);
// Search for a matching configuration, reducing the complexity
// each time until we get something that matches.
if (!d->eglContext->chooseConfig(configProps)) {
delete d->eglContext;
d->eglContext = 0;
return false;
}
// Inform the higher layers about the actual format properties.
qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config());
// Create a new context for the configuration.
if (!d->eglContext->createContext
(shareContext ? shareContext->d_func()->eglContext : 0)) {
delete d->eglContext;
d->eglContext = 0;
return false;
}
d->sharing = d->eglContext->isSharing();
if (d->sharing && shareContext)
const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;
#if defined(EGL_VERSION_1_1)
if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)
eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());
#endif
// Create the EGL surface to draw into.
d->eglSurface = d->eglContext->createSurface(device());
if (d->eglSurface == EGL_NO_SURFACE) {
delete d->eglContext;
d->eglContext = 0;
return false;
}
return true;
}
QString SharePlugin::dbusPath() const
{
return "/modules/kdeconnect/devices/" + device()->id() + "/share";
}
GpuDevice GraphicsInstance::CreateGpuDevice(int , bool, bool)
{
auto canPresent = [](vk::PhysicalDevice dev)
{
auto queueProperties = dev.getQueueFamilyProperties();
for (auto&& queueProp : queueProperties)
{
for (uint32_t i = 0; i < queueProp.queueCount(); ++i)
{
#if defined(PLATFORM_WINDOWS)
if (dev.getWin32PresentationSupportKHR(i))
#endif
{
return true;
}
}
}
return false;
};
int devId = 0;
for (devId = 0; devId < m_devices.size(); ++devId)
{
if (canPresent(m_devices[devId]))
break;
}
auto&& physDev = m_devices[devId]; // assuming first device is best
// layers
std::vector<vk::LayerProperties> devLayers;
physDev.enumerateDeviceLayerProperties(devLayers);
std::vector<const char*> layers;
{
// lunargvalidation list order
F_LOG("Enabled Vulkan debug layers for device:\n");
for (auto&& it : layerOrder)
{
auto found = std::find_if(devLayers.begin(), devLayers.end(), [&](const vk::LayerProperties& layer)
{
return it == layer.layerName();
});
if (found != devLayers.end())
{
layers.push_back(it.c_str());
m_layers.push_back(*found);
F_LOG("%s\n", found->layerName());
}
}
}
// extensions
std::vector<vk::ExtensionProperties> devExts;
auto res = physDev.enumerateDeviceExtensionProperties("", devExts);
if (res != vk::Result::eSuccess)
{
auto error = vk::getString(res);
F_LOG("Device creation error: %s\n", error.c_str());
}
std::vector<const char*> extensions;
{
// lunargvalidation list order
F_LOG("Enabled Vulkan extensions for device:\n");
for (auto&& it : devExtOrder)
{
auto found = std::find_if(devExts.begin(), devExts.end(), [&](const vk::ExtensionProperties& layer)
{
return it == layer.extensionName();
});
if (found != devExts.end())
{
extensions.push_back(it.c_str());
m_extensions.push_back(*found);
F_LOG("found %s\n", found->extensionName());
}
}
}
// queue
//auto queueProperties = vk::getPhysicalDeviceQueueFamilyProperties(physDev);
auto queueProperties = physDev.getQueueFamilyProperties();
std::vector<vk::DeviceQueueCreateInfo> queueInfos;
uint32_t i = 0;
std::vector<std::vector<float>> priorities;
for (auto&& queueProp : queueProperties)
{
priorities.push_back(std::vector<float>());
for (size_t k = 0; k < queueProp.queueCount(); ++k)
{
priorities[i].push_back(1.f);
}
vk::DeviceQueueCreateInfo queueInfo = vk::DeviceQueueCreateInfo()
.sType(vk::StructureType::eDeviceQueueCreateInfo)
.queueFamilyIndex(i)
.queueCount(queueProp.queueCount())
.pQueuePriorities(priorities[i].data());
// queue priorities go here.
queueInfos.push_back(queueInfo);
++i;
}
auto features = physDev.getFeatures();
auto device_info = vk::DeviceCreateInfo()
.sType(vk::StructureType::eDeviceCreateInfo)
.queueCreateInfoCount(static_cast<uint32_t>(queueInfos.size()))
.pQueueCreateInfos(queueInfos.data())
.enabledLayerCount(static_cast<uint32_t>(layers.size()))
.ppEnabledLayerNames(layers.data())
.enabledExtensionCount(static_cast<uint32_t>(extensions.size()))
.ppEnabledExtensionNames(extensions.data())
.pEnabledFeatures(&features);
auto dev = physDev.createDevice(device_info, m_alloc_info);
FazPtrVk<vk::Device> device(dev, [=](vk::Device ist)
{
ist.destroy(&m_alloc_info);
});
return GpuDevice(device, m_alloc_info, false);
}
bool SensorService::threadLoop()
{
LOGD("nuSensorService thread starting...");
const size_t numEventMax = 16 * (1 + mVirtualSensorList.size());
sensors_event_t buffer[numEventMax];
sensors_event_t scratch[numEventMax];
SensorDevice& device(SensorDevice::getInstance());
const size_t vcount = mVirtualSensorList.size();
ssize_t count;
do {
count = device.poll(buffer, numEventMax);
if (count<0) {
LOGE("sensor poll failed (%s)", strerror(-count));
break;
}
recordLastValue(buffer, count);
// handle virtual sensors
if (count && vcount) {
sensors_event_t const * const event = buffer;
const DefaultKeyedVector<int, SensorInterface*> virtualSensors(
getActiveVirtualSensors());
const size_t activeVirtualSensorCount = virtualSensors.size();
if (activeVirtualSensorCount) {
size_t k = 0;
SensorFusion& fusion(SensorFusion::getInstance());
if (fusion.isEnabled()) {
for (size_t i=0 ; i<size_t(count) ; i++) {
fusion.process(event[i]);
}
}
for (size_t i=0 ; i<size_t(count) ; i++) {
for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {
sensors_event_t out;
if (virtualSensors.valueAt(j)->process(&out, event[i])) {
buffer[count + k] = out;
k++;
}
}
}
if (k) {
// record the last synthesized values
recordLastValue(&buffer[count], k);
count += k;
// sort the buffer by time-stamps
sortEventBuffer(buffer, count);
}
}
}
// send our events to clients...
const SortedVector< wp<SensorEventConnection> > activeConnections(
getActiveConnections());
size_t numConnections = activeConnections.size();
for (size_t i=0 ; i<numConnections ; i++) {
sp<SensorEventConnection> connection(
activeConnections[i].promote());
if (connection != 0) {
connection->sendEvents(buffer, count, scratch);
}
}
} while (count >= 0 || Thread::exitPending());
<<<<<<< HEAD
/*-------------------------------------------------
battery_save - stores the battery
backed RAM for an image. The file name is
created from the machine driver name and the
image name.
-------------------------------------------------*/
void device_image_interface::battery_save(const void *buffer, int length)
{
std::string fname = std::string(device().machine().system().name).append(PATH_SEPARATOR).append(m_basename_noext.c_str()).append(".nv");
image_battery_save_by_name(device().machine().options(), fname.c_str(), buffer, length);
}
void
CanvasLayerD3D10::Initialize(const Data& aData)
{
NS_ASSERTION(mSurface == nullptr, "BasicCanvasLayer::Initialize called twice!");
if (aData.mSurface) {
mSurface = aData.mSurface;
NS_ASSERTION(!aData.mGLContext && !aData.mDrawTarget,
"CanvasLayer can't have both surface and WebGLContext/DrawTarget");
mNeedsYFlip = false;
mDataIsPremultiplied = true;
} else if (aData.mGLContext) {
mGLContext = aData.mGLContext;
NS_ASSERTION(mGLContext->IsOffscreen(), "Canvas GLContext must be offscreen.");
mDataIsPremultiplied = aData.mIsGLAlphaPremult;
mNeedsYFlip = true;
GLScreenBuffer* screen = mGLContext->Screen();
SurfaceStreamType streamType =
SurfaceStream::ChooseGLStreamType(SurfaceStream::MainThread,
screen->PreserveBuffer());
SurfaceFactory_GL* factory = nullptr;
if (!mForceReadback) {
factory = SurfaceFactory_ANGLEShareHandle::Create(mGLContext,
device(),
screen->Caps());
}
if (factory) {
screen->Morph(factory, streamType);
}
} else if (aData.mDrawTarget) {
mDrawTarget = aData.mDrawTarget;
mNeedsYFlip = false;
mDataIsPremultiplied = true;
void *texture = mDrawTarget->GetNativeSurface(NATIVE_SURFACE_D3D10_TEXTURE);
if (texture) {
mTexture = static_cast<ID3D10Texture2D*>(texture);
NS_ASSERTION(!aData.mGLContext && !aData.mSurface,
"CanvasLayer can't have both surface and WebGLContext/Surface");
mBounds.SetRect(0, 0, aData.mSize.width, aData.mSize.height);
device()->CreateShaderResourceView(mTexture, nullptr, getter_AddRefs(mSRView));
return;
}
// XXX we should store mDrawTarget and use it directly in UpdateSurface,
// bypassing Thebes
mSurface = gfxPlatform::GetPlatform()->GetThebesSurfaceForDrawTarget(mDrawTarget);
} else {
NS_ERROR("CanvasLayer created without mSurface, mDrawTarget or mGLContext?");
}
mBounds.SetRect(0, 0, aData.mSize.width, aData.mSize.height);
if (mSurface && mSurface->GetType() == gfxASurface::SurfaceTypeD2D) {
void *data = mSurface->GetData(&gKeyD3D10Texture);
if (data) {
mTexture = static_cast<ID3D10Texture2D*>(data);
mIsD2DTexture = true;
device()->CreateShaderResourceView(mTexture, nullptr, getter_AddRefs(mSRView));
mHasAlpha =
mSurface->GetContentType() == gfxASurface::CONTENT_COLOR_ALPHA;
return;
}
}
mIsD2DTexture = false;
// Create a texture in case we need to readback.
CD3D10_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, mBounds.width, mBounds.height, 1, 1);
desc.Usage = D3D10_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
HRESULT hr = device()->CreateTexture2D(&desc, nullptr, getter_AddRefs(mTexture));
if (FAILED(hr)) {
NS_WARNING("Failed to create texture for CanvasLayer!");
return;
}
device()->CreateShaderResourceView(mTexture, nullptr, getter_AddRefs(mUploadSRView));
}
bool device_image_interface::load_software(software_list_device &swlist, const char *swname, const rom_entry *start)
{
std::string locationtag, breakstr("%");
const rom_entry *region;
bool retVal = FALSE;
int warningcount = 0;
for (region = start; region != nullptr; region = rom_next_region(region))
{
/* loop until we hit the end of this region */
const rom_entry *romp = region + 1;
while (!ROMENTRY_ISREGIONEND(romp))
{
/* handle files */
if (ROMENTRY_ISFILE(romp))
{
file_error filerr = FILERR_NOT_FOUND;
UINT32 crc = 0;
bool has_crc = hash_collection(ROM_GETHASHDATA(romp)).crc(crc);
software_info *swinfo = swlist.find(swname);
if (swinfo == nullptr)
return false;
UINT32 supported = swinfo->supported();
if (supported == SOFTWARE_SUPPORTED_PARTIAL)
osd_printf_error("WARNING: support for software %s (in list %s) is only partial\n", swname, swlist.list_name());
if (supported == SOFTWARE_SUPPORTED_NO)
osd_printf_error("WARNING: support for software %s (in list %s) is only preliminary\n", swname, swlist.list_name());
// attempt reading up the chain through the parents and create a locationtag std::string in the format
// " swlist % clonename % parentname "
// below, we have the code to split the elements and to create paths to load from
while (swinfo != nullptr)
{
locationtag.append(swinfo->shortname()).append(breakstr);
const char *parentname = swinfo->parentname();
swinfo = (parentname != nullptr) ? swlist.find(parentname) : nullptr;
}
// strip the final '%'
locationtag.erase(locationtag.length() - 1, 1);
// check if locationtag actually contains two locations separated by '%'
// (i.e. check if we are dealing with a clone in softwarelist)
std::string tag2, tag3, tag4(locationtag), tag5;
int separator = tag4.find_first_of('%');
if (separator != -1)
{
// we are loading a clone through softlists, split the setname from the parentname
tag5.assign(tag4.substr(separator + 1, tag4.length() - separator + 1));
tag4.erase(separator, tag4.length() - separator);
}
// prepare locations where we have to load from: list/parentname & list/clonename
std::string tag1(swlist.list_name());
tag1.append(PATH_SEPARATOR);
tag2.assign(tag1.append(tag4));
tag1.assign(swlist.list_name());
tag1.append(PATH_SEPARATOR);
tag3.assign(tag1.append(tag5));
if (tag5.find_first_of('%') != -1)
fatalerror("We do not support clones of clones!\n");
// try to load from the available location(s):
// - if we are not using lists, we have regiontag only;
// - if we are using lists, we have: list/clonename, list/parentname, clonename, parentname
// try to load from list/setname
if ((m_mame_file == nullptr) && (tag2.c_str() != nullptr))
filerr = common_process_file(device().machine().options(), tag2.c_str(), has_crc, crc, romp, &m_mame_file);
// try to load from list/parentname
if ((m_mame_file == nullptr) && (tag3.c_str() != nullptr))
filerr = common_process_file(device().machine().options(), tag3.c_str(), has_crc, crc, romp, &m_mame_file);
// try to load from setname
if ((m_mame_file == nullptr) && (tag4.c_str() != nullptr))
filerr = common_process_file(device().machine().options(), tag4.c_str(), has_crc, crc, romp, &m_mame_file);
// try to load from parentname
if ((m_mame_file == nullptr) && (tag5.c_str() != nullptr))
filerr = common_process_file(device().machine().options(), tag5.c_str(), has_crc, crc, romp, &m_mame_file);
warningcount += verify_length_and_hash(m_mame_file,ROM_GETNAME(romp),ROM_GETLENGTH(romp),hash_collection(ROM_GETHASHDATA(romp)));
if (filerr == FILERR_NONE)
{
m_file = *m_mame_file;
retVal = TRUE;
}
break; // load first item for start
}
romp++; /* something else; skip */
}
}
if (warningcount > 0)
{
osd_printf_error("WARNING: the software item might not run correctly.\n");
}
return retVal;
}
void
ContainerLayerD3D10::RenderLayer()
{
float renderTargetOffset[] = { 0, 0 };
nsIntRect visibleRect = mVisibleRegion.GetBounds();
float opacity = GetEffectiveOpacity();
bool useIntermediate = UseIntermediateSurface();
nsRefPtr<ID3D10RenderTargetView> previousRTView;
nsRefPtr<ID3D10Texture2D> renderTexture;
nsRefPtr<ID3D10RenderTargetView> rtView;
float previousRenderTargetOffset[2];
nsIntSize previousViewportSize;
gfx3DMatrix oldViewMatrix;
if (useIntermediate) {
device()->OMGetRenderTargets(1, getter_AddRefs(previousRTView), nullptr);
D3D10_TEXTURE2D_DESC desc;
memset(&desc, 0, sizeof(D3D10_TEXTURE2D_DESC));
desc.ArraySize = 1;
desc.MipLevels = 1;
desc.Width = visibleRect.width;
desc.Height = visibleRect.height;
desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;
desc.SampleDesc.Count = 1;
desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
HRESULT hr;
hr = device()->CreateTexture2D(&desc, nullptr, getter_AddRefs(renderTexture));
if (FAILED(hr)) {
LayerManagerD3D10::ReportFailure(NS_LITERAL_CSTRING("Failed to create new texture for ContainerLayerD3D10!"),
hr);
return;
}
hr = device()->CreateRenderTargetView(renderTexture, nullptr, getter_AddRefs(rtView));
NS_ASSERTION(SUCCEEDED(hr), "Failed to create render target view for ContainerLayerD3D10!");
effect()->GetVariableByName("vRenderTargetOffset")->
GetRawValue(previousRenderTargetOffset, 0, 8);
previousViewportSize = mD3DManager->GetViewport();
if (mVisibleRegion.GetNumRects() != 1 || !(GetContentFlags() & CONTENT_OPAQUE)) {
const gfx3DMatrix& transform3D = GetEffectiveTransform();
gfxMatrix transform;
// If we have an opaque ancestor layer, then we can be sure that
// all the pixels we draw into are either opaque already or will be
// covered by something opaque. Otherwise copying up the background is
// not safe.
if (mSupportsComponentAlphaChildren) {
bool is2d = transform3D.Is2D(&transform);
NS_ASSERTION(is2d, "Transform should be 2d when mSupportsComponentAlphaChildren.");
// Copy background up from below. This applies any 2D transform that is
// applied to use relative to our parent, and compensates for the offset
// that was applied on our parent's rendering.
D3D10_BOX srcBox;
srcBox.left = std::max<int32_t>(visibleRect.x + int32_t(transform.x0) - int32_t(previousRenderTargetOffset[0]), 0);
srcBox.top = std::max<int32_t>(visibleRect.y + int32_t(transform.y0) - int32_t(previousRenderTargetOffset[1]), 0);
srcBox.right = std::min<int32_t>(srcBox.left + visibleRect.width, previousViewportSize.width);
srcBox.bottom = std::min<int32_t>(srcBox.top + visibleRect.height, previousViewportSize.height);
srcBox.back = 1;
srcBox.front = 0;
nsRefPtr<ID3D10Resource> srcResource;
previousRTView->GetResource(getter_AddRefs(srcResource));
device()->CopySubresourceRegion(renderTexture, 0,
0, 0, 0,
srcResource, 0,
&srcBox);
} else {
float black[] = { 0, 0, 0, 0};
device()->ClearRenderTargetView(rtView, black);
}
}
ID3D10RenderTargetView *rtViewPtr = rtView;
device()->OMSetRenderTargets(1, &rtViewPtr, nullptr);
renderTargetOffset[0] = (float)visibleRect.x;
renderTargetOffset[1] = (float)visibleRect.y;
effect()->GetVariableByName("vRenderTargetOffset")->
SetRawValue(renderTargetOffset, 0, 8);
mD3DManager->SetViewport(nsIntSize(visibleRect.Size()));
}
D3D10_RECT oldD3D10Scissor;
UINT numRects = 1;
device()->RSGetScissorRects(&numRects, &oldD3D10Scissor);
// Convert scissor to an nsIntRect. D3D10_RECT's are exclusive
// on the bottom and right values.
nsIntRect oldScissor(oldD3D10Scissor.left,
oldD3D10Scissor.top,
oldD3D10Scissor.right - oldD3D10Scissor.left,
oldD3D10Scissor.bottom - oldD3D10Scissor.top);
nsAutoTArray<Layer*, 12> children;
SortChildrenBy3DZOrder(children);
/*
* Render this container's contents.
*/
for (uint32_t i = 0; i < children.Length(); i++) {
LayerD3D10* layerToRender = static_cast<LayerD3D10*>(children.ElementAt(i)->ImplData());
if (layerToRender->GetLayer()->GetEffectiveVisibleRegion().IsEmpty()) {
continue;
}
nsIntRect scissorRect =
layerToRender->GetLayer()->CalculateScissorRect(oldScissor, nullptr);
if (scissorRect.IsEmpty()) {
continue;
}
D3D10_RECT d3drect;
d3drect.left = scissorRect.x;
d3drect.top = scissorRect.y;
d3drect.right = scissorRect.x + scissorRect.width;
d3drect.bottom = scissorRect.y + scissorRect.height;
device()->RSSetScissorRects(1, &d3drect);
layerToRender->RenderLayer();
}
device()->RSSetScissorRects(1, &oldD3D10Scissor);
if (useIntermediate) {
mD3DManager->SetViewport(previousViewportSize);
ID3D10RenderTargetView *rtView = previousRTView;
device()->OMSetRenderTargets(1, &rtView, nullptr);
effect()->GetVariableByName("vRenderTargetOffset")->
SetRawValue(previousRenderTargetOffset, 0, 8);
SetEffectTransformAndOpacity();
ID3D10EffectTechnique *technique;
if (LoadMaskTexture()) {
if (GetTransform().CanDraw2D()) {
technique = SelectShader(SHADER_RGBA | SHADER_PREMUL | SHADER_MASK);
} else {
technique = SelectShader(SHADER_RGBA | SHADER_PREMUL | SHADER_MASK_3D);
}
} else {
technique = SelectShader(SHADER_RGBA | SHADER_PREMUL | SHADER_NO_MASK);
}
effect()->GetVariableByName("vLayerQuad")->AsVector()->SetFloatVector(
ShaderConstantRectD3D10(
(float)visibleRect.x,
(float)visibleRect.y,
(float)visibleRect.width,
(float)visibleRect.height)
);
technique->GetPassByIndex(0)->Apply(0);
ID3D10ShaderResourceView *view;
device()->CreateShaderResourceView(renderTexture, nullptr, &view);
device()->PSSetShaderResources(0, 1, &view);
device()->Draw(4, 0);
view->Release();
}
}
bool device_image_interface::load_internal(const char *path, bool is_create, int create_format, option_resolution *create_args, bool just_load)
{
UINT32 open_plan[4];
int i;
bool softload = FALSE;
m_from_swlist = FALSE;
// if the path contains no period, we are using softlists, so we won't create an image
std::string pathstr(path);
bool filename_has_period = (pathstr.find_last_of('.') != -1) ? TRUE : FALSE;
/* first unload the image */
unload();
/* clear any possible error messages */
clear_error();
/* we are now loading */
m_is_loading = TRUE;
/* record the filename */
m_err = set_image_filename(path);
if (m_err)
goto done;
if (core_opens_image_file())
{
/* Check if there's a software list defined for this device and use that if we're not creating an image */
if (!filename_has_period && !just_load)
{
softload = load_software_part(path, m_software_part_ptr);
if (softload)
{
m_software_info_ptr = &m_software_part_ptr->info();
m_software_list_name.assign(m_software_info_ptr->list().list_name());
m_full_software_name.assign(m_software_part_ptr->info().shortname());
// if we had launched from softlist with a specified part, e.g. "shortname:part"
// we would have recorded the wrong name, so record it again based on software_info
if (m_software_info_ptr && !m_full_software_name.empty())
m_err = set_image_filename(m_full_software_name.c_str());
// check if image should be read-only
const char *read_only = get_feature("read_only");
if (read_only && !strcmp(read_only, "true")) {
make_readonly();
}
m_from_swlist = TRUE;
}
}
if (is_create || filename_has_period)
{
/* determine open plan */
determine_open_plan(is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !m_file && open_plan[i]; i++)
{
/* open the file */
m_err = load_image_by_path(open_plan[i], path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
/* Copy some image information when we have been loaded through a software list */
if ( m_software_info_ptr )
{
// sanitize
if (m_software_info_ptr->longname() == nullptr || m_software_info_ptr->publisher() == nullptr || m_software_info_ptr->year() == nullptr)
fatalerror("Each entry in an XML list must have all of the following fields: description, publisher, year!\n");
// store
m_longname = m_software_info_ptr->longname();
m_manufacturer = m_software_info_ptr->publisher();
m_year = m_software_info_ptr->year();
//m_playable = m_software_info_ptr->supported();
}
/* did we fail to find the file? */
if (!is_loaded() && !softload)
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
}
/* call device load or create */
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
m_err = (image_error_t)finish_load();
if (m_err)
goto done;
}
/* success! */
done:
if (just_load) {
if(m_err) clear();
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
if (m_err!=0) {
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
else
osd_printf_error("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if (device().machine().time() > attotime::zero && is_reset_on_load())
device().machine().schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
osd_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
bool INDIDeviceControllerInstance::ExecuteGlobal()
{
Console console;
Exception::DisableGUIOutput();
INDIClient* indi = INDIClient::TheClient();
try
{
if ( p_serverConnect )
{
if ( indi == nullptr )
{
indi = INDIClient::NewClient( p_serverHostName.ToUTF8(), p_serverPort );
if ( p_verbosity > 0 )
{
console.NoteLn( "<end><cbr>INDI Control Client --- (C) Klaus Kretzschmar, 2014-2016" );
console.Flush();
}
}
indi->SetVerbosity( p_verbosity );
if ( !indi->IsServerConnected() )
{
indi->connectServer();
if ( !indi->IsServerConnected() )
throw Error( "INDIDeviceControllerInstance: Failure to connect to INDI server " + p_serverHostName + ", port=" + String( p_serverPort ) );
if ( p_verbosity > 0 )
{
console.NoteLn( "* Successfully connected to INDI server " + p_serverHostName + ", port=" + String( p_serverPort ) );
console.Flush();
}
}
if ( !p_serverCommand.IsEmpty() )
{
console.EnableAbort();
if ( p_serverCommand == "GET" )
{
o_getCommandResult.Clear();
String device( PropertyUtils::Device( p_getCommandParameters ) );
String property( PropertyUtils::Property( p_getCommandParameters ) );
String element( PropertyUtils::Element( p_getCommandParameters ) );
INDIPropertyListItem item;
if ( !indi->GetPropertyItem( device, property, element, item ) )
throw Error( "INDIDeviceControllerInstance: Could not get value of property '" + String( p_getCommandParameters ) + "'" );
o_getCommandResult = item.PropertyValue;
if ( p_verbosity > 1 )
console.WriteLn( "<end><cbr>Device=" + device +
", Property=" + property +
", Element=" + element +
", Value=" + o_getCommandResult );
}
else if ( p_serverCommand == "SET" )
{
for ( auto newProperty : p_newProperties )
{
GetNewPropertyListItemParametersFromKey( newProperty );
if ( !indi->SendNewPropertyItem( newProperty, false/*async*/ ) )
throw Error( "INDIDeviceControllerInstance: Failure to send new property values." );
}
p_newProperties.Clear();
}
else if ( p_serverCommand == "SET_ASYNC" )
{
for ( auto newProperty : p_newProperties )
{
GetNewPropertyListItemParametersFromKey( newProperty );
if ( !indi->SendNewPropertyItem( newProperty, true/*async*/ ) )
throw Error( "INDIDeviceControllerInstance: Failure to send new property values (asynchronous)." );
}
p_newProperties.Clear();
}
else
throw Error( "INDIDeviceControllerInstance: Unknown command '" + p_serverCommand + "'" );
console.Flush();
}
AcquireINDIClientProperties();
}
else
{
if ( indi != nullptr )
{
if ( indi->IsServerConnected() )
{
AcquireINDIClientProperties();
indi->SetVerbosity( p_verbosity );
indi->disconnectServer();
if ( p_verbosity > 0 )
console.NoteLn( "* Disconnected from INDI server " + p_serverHostName + ", port=" + String( p_serverPort ) );
}
INDIClient::DestroyClient();
}
}
return true;
}
catch ( const Exception& x )
{
if ( p_verbosity > 0 )
x.Show();
return false;
}
catch ( ... )
{
throw;
}
}
int
main(int argc, char** argv)
{
if (argc < 2)
usage();
BNetworkDevice device(argv[1]);
if (!device.Exists()) {
fprintf(stderr, "\"%s\" does not exist!\n", argv[1]);
return 1;
}
if (!device.IsWireless()) {
fprintf(stderr, "\"%s\" is not a WLAN device!\n", argv[1]);
return 1;
}
if (argc > 2) {
if (!strcmp(argv[2], "join")) {
if (argc < 4)
usage();
const char* password = NULL;
if (argc == 5)
password = argv[4];
status_t status = device.JoinNetwork(argv[3], password);
if (status != B_OK) {
fprintf(stderr, "joining network failed: %s\n",
strerror(status));
return 1;
}
} else if (!strcmp(argv[2], "leave")) {
if (argc < 4)
usage();
status_t status = device.LeaveNetwork(argv[3]);
if (status != B_OK) {
fprintf(stderr, "leaving network failed: %s\n",
strerror(status));
return 1;
}
} else if (!strcmp(argv[2], "list")) {
if (argc == 4) {
// list the named entry
wireless_network network;
BNetworkAddress link;
status_t status = link.SetTo(AF_LINK, argv[3]);
if (status == B_OK)
status = device.GetNetwork(link, network);
else
status = device.GetNetwork(argv[3], network);
if (status != B_OK) {
fprintf(stderr, "getting network failed: %s\n",
strerror(status));
return 1;
}
show(network);
} else {
// list all
wireless_network network;
uint32 cookie = 0;
while (device.GetNextNetwork(cookie, network) == B_OK)
show(network);
}
} else
usage();
} else {
// show associated networks
wireless_network network;
uint32 cookie = 0;
while (device.GetNextAssociatedNetwork(cookie, network) == B_OK) {
show(network);
}
if (cookie == 0)
puts("no associated networks found.");
}
return 0;
}