mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 06:15:58 +00:00
fix: use SteamVR compositor on Quest
This commit is contained in:
1 parent
59f752c70d
commit
92f2696a0c
16 files changed
+793
-26
No files matched your search
@@ -0,0 +1,78 @@
|
||||
#include "../src/wsi_capture.cpp"
|
||||
#include <cassert>
|
||||
|
||||
static VkResult resetResult = VK_SUCCESS;
|
||||
static unsigned submitted, presented, copied, blitted;
|
||||
static VkSemaphore originalWaits[2]{(VkSemaphore)10, (VkSemaphore)11};
|
||||
static VkSemaphore expectedPresent;
|
||||
static VkResult VKAPI_CALL Present(VkQueue, const VkPresentInfoKHR *info) {
|
||||
presented++;
|
||||
if (expectedPresent) assert(info->waitSemaphoreCount == 1 && info->pWaitSemaphores[0] == expectedPresent);
|
||||
else assert(info->waitSemaphoreCount == 2 && info->pWaitSemaphores[0] == originalWaits[0]);
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
int main() {
|
||||
char path[] = "/tmp/droiddeck-wsi-XXXXXX"; int fd = mkstemp(path); assert(fd >= 0);
|
||||
DroidDeckXrTracking tracking{};
|
||||
tracking.magic = DROIDDECK_XR_MAGIC; tracking.version = DROIDDECK_XR_VERSION; tracking.active = 1;
|
||||
tracking.sampled_ns = xr_frame_now(); tracking.period_ns = 11111111;
|
||||
for (auto &eye : tracking.eyes) {
|
||||
eye.width = eye.height = 4; eye.pose.orientation[3] = 1; eye.pose.flags = 15;
|
||||
eye.fov[0] = eye.fov[3] = -0.7f; eye.fov[1] = eye.fov[2] = 0.7f;
|
||||
}
|
||||
assert(write(fd, &tracking, sizeof(tracking)) == sizeof(tracking)); close(fd);
|
||||
auto device = std::make_unique<Device>();
|
||||
device->ResetCommandBuffer = [](VkCommandBuffer, VkCommandBufferResetFlags) { return resetResult; };
|
||||
device->BeginCommandBuffer = [](VkCommandBuffer, const VkCommandBufferBeginInfo *) { return VK_SUCCESS; };
|
||||
device->EndCommandBuffer = [](VkCommandBuffer) { return VK_SUCCESS; };
|
||||
device->ResetFences = [](VkDevice, uint32_t, const VkFence *) { return VK_SUCCESS; };
|
||||
device->CmdPipelineBarrier = [](VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags,
|
||||
VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t buffers, const VkBufferMemoryBarrier *host,
|
||||
uint32_t images, const VkImageMemoryBarrier *image) {
|
||||
assert(images == 1 && image->srcQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED);
|
||||
if (buffers) assert(host->dstAccessMask == VK_ACCESS_HOST_READ_BIT);
|
||||
};
|
||||
device->CmdBlitImage = [](VkCommandBuffer, VkImage, VkImageLayout source, VkImage, VkImageLayout destination,
|
||||
uint32_t count, const VkImageBlit *blit, VkFilter filter) {
|
||||
assert(source == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL && destination == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
||||
assert(count == 1 && filter == VK_FILTER_NEAREST && blit->srcOffsets[1].x == 8); blitted++;
|
||||
};
|
||||
device->CmdCopyImageToBuffer = [](VkCommandBuffer, VkImage, VkImageLayout layout, VkBuffer,
|
||||
uint32_t count, const VkBufferImageCopy *copy) {
|
||||
assert(layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL && count == 1 && copy->imageExtent.width == 8); copied++;
|
||||
};
|
||||
device->QueueSubmit = [](VkQueue, uint32_t count, const VkSubmitInfo *info, VkFence) {
|
||||
assert(count == 1 && info->waitSemaphoreCount == 2 && info->signalSemaphoreCount == 1);
|
||||
for (int i = 0; i < 2; i++) assert(info->pWaitSemaphores[i] == originalWaits[i]
|
||||
&& info->pWaitDstStageMask[i] == VK_PIPELINE_STAGE_TRANSFER_BIT);
|
||||
submitted++; return VK_SUCCESS;
|
||||
};
|
||||
device->DestroySemaphore = [](VkDevice, VkSemaphore, const VkAllocationCallbacks *) {};
|
||||
VkDevice handle = (VkDevice)1; VkQueue queue = (VkQueue)2;
|
||||
device->handle = handle; device->queues[queue] = 7;
|
||||
auto chain = std::make_unique<Swapchain>(path);
|
||||
chain->device = device.get(); chain->family = 7; chain->initialized = true; chain->extent = {8, 4};
|
||||
chain->images = {(VkImage)20, (VkImage)21, (VkImage)22};
|
||||
chain->ready = {(VkSemaphore)30, (VkSemaphore)31, (VkSemaphore)32};
|
||||
devices[handle] = std::move(device);
|
||||
VkSwapchainKHR swapchain = (VkSwapchainKHR)3; swapchains[swapchain] = std::move(chain);
|
||||
VkPresentInfoKHR info{VK_STRUCTURE_TYPE_PRESENT_INFO_KHR};
|
||||
uint32_t index = 0; info.pImageIndices = &index; info.swapchainCount = 1; info.pSwapchains = &swapchain;
|
||||
info.waitSemaphoreCount = 2; info.pWaitSemaphores = originalWaits;
|
||||
for (index = 0; index < 3; index++) {
|
||||
expectedPresent = (VkSemaphore)(uintptr_t)(30 + index);
|
||||
assert(droiddeck_wsi_present(handle, queue, &info, Present) == VK_SUCCESS);
|
||||
}
|
||||
index = 0; expectedPresent = VK_NULL_HANDLE;
|
||||
assert(droiddeck_wsi_present(handle, queue, &info, Present) == VK_SUCCESS);
|
||||
assert(submitted == 3 && presented == 4 && copied == 3 && blitted == 3);
|
||||
for (const auto &slot : swapchains[swapchain]->slots) assert(slot.busy && slot.queued && xr_frame_valid(slot.header));
|
||||
swapchains[swapchain]->slots[0].busy = false;
|
||||
resetResult = VK_ERROR_DEVICE_LOST;
|
||||
assert(droiddeck_wsi_present(handle, queue, &info, Present) == VK_ERROR_DEVICE_LOST);
|
||||
assert(droiddeck_wsi_present(handle, queue, &info, Present) == VK_ERROR_DEVICE_LOST);
|
||||
assert(submitted == 3 && presented == 4);
|
||||
droiddeck_wsi_destroy(handle); unlink(path);
|
||||
std::puts("WSI synchronization passed: original waits retained, per-image completion, bounded in-flight buffers and fatal error propagation");
|
||||
}
|
||||
@@ -43,7 +43,7 @@ int main(int argc, char **argv) {
|
||||
auto valid = Header(); assert(xr_frame_valid(valid));
|
||||
valid.color_space = DROIDDECK_XR_COLOR_SRGB_RGBA8; assert(xr_frame_valid(valid));
|
||||
auto unknownColor = valid; unknownColor.color_space = 3; assert(!xr_frame_valid(unknownColor));
|
||||
auto invalid = valid; invalid.version++; assert(!xr_frame_valid(invalid));
|
||||
auto invalid = valid; invalid.version = 3; assert(!xr_frame_valid(invalid));
|
||||
invalid = valid; invalid.width = 3; assert(!xr_frame_valid(invalid));
|
||||
invalid = valid; invalid.bytes--; assert(!xr_frame_valid(invalid));
|
||||
invalid = valid; invalid.width = 8192; invalid.height = 4096; assert(!xr_frame_valid(invalid));
|
||||
@@ -111,7 +111,7 @@ int main(int argc, char **argv) {
|
||||
assert(acknowledged == delayedHeader.frame_id && receiver.Take(&taken));
|
||||
close(delayed);
|
||||
receiver.Stop(); assert(receiver.Start(socketPath));
|
||||
int descriptor = Connect(socketPath); auto header = Header(); header.version++;
|
||||
int descriptor = Connect(socketPath); auto header = Header(); header.version = 3;
|
||||
assert(xr_frame_io(descriptor, &header, sizeof(header), true, xr_frame_now() + 200000000LL));
|
||||
close(descriptor); WaitRejected(receiver, 1); assert(!receiver.Take(&taken));
|
||||
descriptor = Connect(socketPath); header = Header(); header.captured_ns += 1000000000LL;
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
#include "../src/xr_frame_channel.h"
|
||||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <sys/syscall.h>
|
||||
|
||||
static DroidDeckXrFrameHeader Header() {
|
||||
DroidDeckXrFrameHeader header{};
|
||||
header.magic = DROIDDECK_XR_FRAME_MAGIC; header.version = DROIDDECK_XR_FRAME_VERSION;
|
||||
header.width = 8; header.height = 4; header.bytes = 128;
|
||||
header.color_space = DROIDDECK_XR_COLOR_SRGB_RGBA8; header.frame_id = 1; header.captured_ns = xr_frame_now();
|
||||
for (int eye = 0; eye < 2; eye++) {
|
||||
for (int axis = 0; axis < 3; axis++) header.eye_pose[eye][axis][axis] = 1;
|
||||
header.projection[eye][0][0] = header.projection[eye][1][1] = 1;
|
||||
header.projection[eye][3][2] = -1;
|
||||
}
|
||||
return header;
|
||||
}
|
||||
|
||||
int main() {
|
||||
char directory[] = "/tmp/droiddeck-shared-XXXXXX"; assert(mkdtemp(directory));
|
||||
std::string path = std::string(directory) + "/frames";
|
||||
int listener = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); assert(listener >= 0);
|
||||
sockaddr_un address{}; address.sun_family = AF_UNIX; std::strcpy(address.sun_path, path.c_str());
|
||||
assert(bind(listener, reinterpret_cast<sockaddr *>(&address), sizeof(address)) == 0);
|
||||
assert(listen(listener, 1) == 0);
|
||||
int buffer = syscall(SYS_memfd_create, "frame-test", 1); assert(buffer >= 0);
|
||||
assert(ftruncate(buffer, 128) == 0);
|
||||
unsigned char pixels[128]; std::memset(pixels, 27, sizeof(pixels));
|
||||
assert(pwrite(buffer, pixels, sizeof(pixels), 0) == sizeof(pixels));
|
||||
auto header = Header();
|
||||
XrFrameSender sender;
|
||||
std::thread peer([&] {
|
||||
int client = accept(listener, nullptr, nullptr); assert(client >= 0);
|
||||
DroidDeckXrFrameHeader received{}; XrFrameDescriptor shared;
|
||||
assert(xr_frame_header(client, received, shared, xr_frame_now() + 1000000000LL));
|
||||
assert(received.version == DROIDDECK_XR_FRAME_SHARED_VERSION && xr_frame_valid(received));
|
||||
assert(shared.fd >= 0 && (fcntl(shared.fd, F_GETFD) & FD_CLOEXEC));
|
||||
unsigned char copy[128]; assert(pread(shared.fd, copy, sizeof(copy), 0) == sizeof(copy));
|
||||
for (auto value : copy) assert(value == 27);
|
||||
assert(xr_frame_io(client, &received.frame_id, sizeof(received.frame_id), true, xr_frame_now() + 1000000000LL));
|
||||
close(client);
|
||||
});
|
||||
assert(sender.SendShared(path, header, buffer)); peer.join();
|
||||
assert(!sender.SharedLeaseLost());
|
||||
XrFrameSender lost;
|
||||
std::thread disconnected([&] {
|
||||
int client = accept(listener, nullptr, nullptr); assert(client >= 0);
|
||||
DroidDeckXrFrameHeader received{}; XrFrameDescriptor shared;
|
||||
assert(xr_frame_header(client, received, shared, xr_frame_now() + 1000000000LL));
|
||||
assert(shared.fd >= 0);
|
||||
close(client);
|
||||
});
|
||||
assert(!lost.SendShared(path, header, buffer)); disconnected.join();
|
||||
assert(lost.SharedLeaseLost());
|
||||
assert(!lost.SendShared(path, header, buffer));
|
||||
close(listener); unlink(path.c_str());
|
||||
XrFrameSender absent;
|
||||
assert(!absent.SendShared(path, header, buffer)); assert(!absent.SharedLeaseLost());
|
||||
XrFrameReceiver receiver; assert(receiver.Start(path));
|
||||
XrFrameSender invalid;
|
||||
// An ordinary file is not a DMA-BUF and must never be acknowledged as one.
|
||||
assert(!invalid.SendShared(path, Header(), buffer));
|
||||
assert(invalid.SharedLeaseLost() && receiver.Rejected() == 1);
|
||||
DroidDeckXrPixels frame; assert(!receiver.Take(&frame));
|
||||
receiver.Stop(); close(buffer); unlink((path + ".lock").c_str()); rmdir(directory);
|
||||
std::puts("XR shared handoff passed: descriptor ownership, copied payload, acknowledgement, disconnect quarantine, absent peer and invalid buffer rejection");
|
||||
}
|
||||
Reference in new issue
Block a user