Merge "BufferHubProducer: don't check user_metadata_size" into pi-dev
diff --git a/cmds/installd/tests/installd_dexopt_test.cpp b/cmds/installd/tests/installd_dexopt_test.cpp
index 668e604..279bce8 100644
--- a/cmds/installd/tests/installd_dexopt_test.cpp
+++ b/cmds/installd/tests/installd_dexopt_test.cpp
@@ -546,7 +546,7 @@
TEST_F(DexoptTest, DexoptPrimaryProfileNonPublic) {
LOG(INFO) << "DexoptPrimaryProfileNonPublic";
CompilePrimaryDexOk("speed-profile",
- DEXOPT_BOOTCOMPLETE | DEXOPT_PROFILE_GUIDED,
+ DEXOPT_BOOTCOMPLETE | DEXOPT_PROFILE_GUIDED | DEXOPT_GENERATE_APP_IMAGE,
app_oat_dir_.c_str(),
kTestAppGid,
DEX2OAT_FROM_SCRATCH);
@@ -555,7 +555,8 @@
TEST_F(DexoptTest, DexoptPrimaryProfilePublic) {
LOG(INFO) << "DexoptPrimaryProfilePublic";
CompilePrimaryDexOk("speed-profile",
- DEXOPT_BOOTCOMPLETE | DEXOPT_PROFILE_GUIDED | DEXOPT_PUBLIC,
+ DEXOPT_BOOTCOMPLETE | DEXOPT_PROFILE_GUIDED | DEXOPT_PUBLIC |
+ DEXOPT_GENERATE_APP_IMAGE,
app_oat_dir_.c_str(),
kTestAppGid,
DEX2OAT_FROM_SCRATCH);
@@ -564,7 +565,8 @@
TEST_F(DexoptTest, DexoptPrimaryBackgroundOk) {
LOG(INFO) << "DexoptPrimaryBackgroundOk";
CompilePrimaryDexOk("speed-profile",
- DEXOPT_IDLE_BACKGROUND_JOB | DEXOPT_PROFILE_GUIDED,
+ DEXOPT_IDLE_BACKGROUND_JOB | DEXOPT_PROFILE_GUIDED |
+ DEXOPT_GENERATE_APP_IMAGE,
app_oat_dir_.c_str(),
kTestAppGid,
DEX2OAT_FROM_SCRATCH);
diff --git a/data/etc/android.software.device_id_attestation.xml b/data/etc/android.software.device_id_attestation.xml
new file mode 100644
index 0000000..4e637ca
--- /dev/null
+++ b/data/etc/android.software.device_id_attestation.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<!-- Feature for devices with Keymaster that support Device ID attestation. -->
+<permissions>
+ <feature name="android.software.device_id_attestation" />
+</permissions>
diff --git a/libs/dumputils/dump_utils.cpp b/libs/dumputils/dump_utils.cpp
index 0fd2b81..835da20 100644
--- a/libs/dumputils/dump_utils.cpp
+++ b/libs/dumputils/dump_utils.cpp
@@ -44,6 +44,7 @@
"android.hardware.audio@2.0::IDevicesFactory",
"android.hardware.bluetooth@1.0::IBluetoothHci",
"android.hardware.camera.provider@2.4::ICameraProvider",
+ "android.hardware.drm@1.0::IDrmFactory",
"android.hardware.graphics.composer@2.1::IComposer",
"android.hardware.media.omx@1.0::IOmx",
"android.hardware.sensors@1.0::ISensors",
diff --git a/libs/nativewindow/AHardwareBuffer.cpp b/libs/nativewindow/AHardwareBuffer.cpp
index f37ef28..49ffc8f 100644
--- a/libs/nativewindow/AHardwareBuffer.cpp
+++ b/libs/nativewindow/AHardwareBuffer.cpp
@@ -60,6 +60,13 @@
return BAD_VALUE;
}
+ if ((desc->usage & (AHARDWAREBUFFER_USAGE_CPU_READ_MASK | AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) &&
+ (desc->usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT)) {
+ ALOGE("AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT requires AHARDWAREBUFFER_USAGE_CPU_READ_NEVER "
+ "and AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER");
+ return BAD_VALUE;
+ }
+
uint64_t usage = AHardwareBuffer_convertToGrallocUsageBits(desc->usage);
sp<GraphicBuffer> gbuffer(new GraphicBuffer(
desc->width, desc->height, format, desc->layers, usage,
diff --git a/libs/ui/Android.bp b/libs/ui/Android.bp
index e477a83..1a9fb8b 100644
--- a/libs/ui/Android.bp
+++ b/libs/ui/Android.bp
@@ -73,6 +73,7 @@
shared_libs: [
"android.hardware.graphics.allocator@2.0",
+ "android.hardware.graphics.common@1.1",
"android.hardware.graphics.mapper@2.0",
"android.hardware.graphics.mapper@2.1",
"android.hardware.configstore@1.0",
@@ -90,6 +91,10 @@
"liblog",
],
+ export_shared_lib_headers: [
+ "android.hardware.graphics.common@1.1",
+ ],
+
static_libs: [
"libarect",
"libgrallocusage",
diff --git a/libs/ui/DebugUtils.cpp b/libs/ui/DebugUtils.cpp
index 58fed84..61df02d 100644
--- a/libs/ui/DebugUtils.cpp
+++ b/libs/ui/DebugUtils.cpp
@@ -23,6 +23,7 @@
using android::base::StringPrintf;
using android::ui::ColorMode;
+using android::ui::RenderIntent;
std::string decodeStandard(android_dataspace dataspace) {
const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
@@ -229,6 +230,15 @@
case ColorMode::DISPLAY_P3:
return std::string("ColorMode::DISPLAY_P3");
+
+ case ColorMode::BT2020:
+ return std::string("ColorMode::BT2020");
+
+ case ColorMode::BT2100_PQ:
+ return std::string("ColorMode::BT2100_PQ");
+
+ case ColorMode::BT2100_HLG:
+ return std::string("ColorMode::BT2100_HLG");
}
return android::base::StringPrintf("Unknown color mode %d", colorMode);
@@ -294,6 +304,20 @@
}
}
+std::string decodeRenderIntent(RenderIntent renderIntent) {
+ switch(renderIntent) {
+ case RenderIntent::COLORIMETRIC:
+ return std::string("RenderIntent::COLORIMETRIC");
+ case RenderIntent::ENHANCE:
+ return std::string("RenderIntent::ENHANCE");
+ case RenderIntent::TONE_MAP_COLORIMETRIC:
+ return std::string("RenderIntent::TONE_MAP_COLORIMETRIC");
+ case RenderIntent::TONE_MAP_ENHANCE:
+ return std::string("RenderIntent::TONE_MAP_ENHANCE");
+ }
+ return std::string("Unknown RenderIntent");
+}
+
std::string to_string(const android::Rect& rect) {
return StringPrintf("(%4d,%4d,%4d,%4d)", rect.left, rect.top, rect.right, rect.bottom);
}
diff --git a/libs/ui/include/ui/DebugUtils.h b/libs/ui/include/ui/DebugUtils.h
index 5e5df43..92b2bfb 100644
--- a/libs/ui/include/ui/DebugUtils.h
+++ b/libs/ui/include/ui/DebugUtils.h
@@ -32,4 +32,5 @@
std::string decodeColorMode(android::ui::ColorMode colormode);
std::string decodeColorTransform(android_color_transform colorTransform);
std::string decodePixelFormat(android::PixelFormat format);
+std::string decodeRenderIntent(android::ui::RenderIntent renderIntent);
std::string to_string(const android::Rect& rect);
diff --git a/libs/ui/include/ui/GraphicTypes.h b/libs/ui/include/ui/GraphicTypes.h
index 92a5519..bd5722f 100644
--- a/libs/ui/include/ui/GraphicTypes.h
+++ b/libs/ui/include/ui/GraphicTypes.h
@@ -24,9 +24,10 @@
namespace android {
namespace ui {
-using android::hardware::graphics::common::V1_0::ColorMode;
+using android::hardware::graphics::common::V1_1::ColorMode;
using android::hardware::graphics::common::V1_1::Dataspace;
using android::hardware::graphics::common::V1_1::PixelFormat;
+using android::hardware::graphics::common::V1_1::RenderIntent;
} // namespace ui
} // namespace android
diff --git a/libs/vr/libbufferhub/Android.bp b/libs/vr/libbufferhub/Android.bp
index 39814cc..b38ecc7 100644
--- a/libs/vr/libbufferhub/Android.bp
+++ b/libs/vr/libbufferhub/Android.bp
@@ -15,6 +15,7 @@
sourceFiles = [
"buffer_hub_client.cpp",
"buffer_hub_rpc.cpp",
+ "detached_buffer.cpp",
"ion_buffer.cpp",
]
@@ -59,6 +60,11 @@
vndk: {
enabled: true,
},
+ target: {
+ vendor: {
+ exclude_srcs: ["detached_buffer.cpp"],
+ },
+ },
}
cc_test {
diff --git a/libs/vr/libbufferhub/buffer_hub-test.cpp b/libs/vr/libbufferhub/buffer_hub-test.cpp
index 660a200..2302828 100644
--- a/libs/vr/libbufferhub/buffer_hub-test.cpp
+++ b/libs/vr/libbufferhub/buffer_hub-test.cpp
@@ -2,8 +2,10 @@
#include <poll.h>
#include <private/dvr/buffer_hub_client.h>
#include <private/dvr/bufferhub_rpc.h>
+#include <private/dvr/detached_buffer.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
+#include <ui/DetachedBufferHandle.h>
#include <mutex>
#include <thread>
@@ -17,22 +19,28 @@
return result; \
})()
+using android::sp;
+using android::GraphicBuffer;
using android::dvr::BufferConsumer;
using android::dvr::BufferHubDefs::kConsumerStateMask;
+using android::dvr::BufferHubDefs::kMetadataHeaderSize;
using android::dvr::BufferHubDefs::kProducerStateBit;
using android::dvr::BufferHubDefs::IsBufferGained;
using android::dvr::BufferHubDefs::IsBufferPosted;
using android::dvr::BufferHubDefs::IsBufferAcquired;
using android::dvr::BufferHubDefs::IsBufferReleased;
using android::dvr::BufferProducer;
+using android::dvr::DetachedBuffer;
using android::pdx::LocalChannelHandle;
using android::pdx::LocalHandle;
using android::pdx::Status;
const int kWidth = 640;
const int kHeight = 480;
+const int kLayerCount = 1;
const int kFormat = HAL_PIXEL_FORMAT_RGBA_8888;
const int kUsage = 0;
+const size_t kUserMetadataSize = 0;
const uint64_t kContext = 42;
const size_t kMaxConsumerCount = 63;
const int kPollTimeoutMs = 100;
@@ -730,6 +738,7 @@
DvrNativeBufferMetadata metadata;
LocalHandle invalid_fence;
+ int p_id = p->id();
// Detach in posted state should fail.
EXPECT_EQ(0, p->PostAsync(&metadata, invalid_fence));
@@ -753,8 +762,8 @@
s1 = p->Detach();
EXPECT_TRUE(s1);
- LocalChannelHandle detached_buffer = s1.take();
- EXPECT_TRUE(detached_buffer.valid());
+ LocalChannelHandle handle = s1.take();
+ EXPECT_TRUE(handle.valid());
// Both producer and consumer should have hangup.
EXPECT_GT(RETRY_EINTR(p->Poll(kPollTimeoutMs)), 0);
@@ -779,4 +788,80 @@
// ConsumerChannel::HandleMessage as the socket is still open but the producer
// is gone.
EXPECT_EQ(s3.error(), EPIPE);
+
+ // Detached buffer handle can be use to construct a new DetachedBuffer object.
+ auto d = DetachedBuffer::Import(std::move(handle));
+ EXPECT_FALSE(handle.valid());
+ EXPECT_TRUE(d->IsValid());
+
+ ASSERT_TRUE(d->buffer() != nullptr);
+ EXPECT_EQ(d->buffer()->initCheck(), 0);
+ EXPECT_EQ(d->id(), p_id);
+}
+
+TEST_F(LibBufferHubTest, TestCreateDetachedBufferFails) {
+ // Buffer Creation will fail: BLOB format requires height to be 1.
+ auto b1 = DetachedBuffer::Create(kWidth, /*height=2*/2, kLayerCount,
+ /*format=*/HAL_PIXEL_FORMAT_BLOB, kUsage,
+ kUserMetadataSize);
+
+ EXPECT_FALSE(b1->IsValid());
+ EXPECT_TRUE(b1->buffer() == nullptr);
+
+ // Buffer Creation will fail: user metadata size too large.
+ auto b2 = DetachedBuffer::Create(
+ kWidth, kHeight, kLayerCount, kFormat, kUsage,
+ /*user_metadata_size=*/std::numeric_limits<size_t>::max());
+
+ EXPECT_FALSE(b2->IsValid());
+ EXPECT_TRUE(b2->buffer() == nullptr);
+
+ // Buffer Creation will fail: user metadata size too large.
+ auto b3 = DetachedBuffer::Create(
+ kWidth, kHeight, kLayerCount, kFormat, kUsage,
+ /*user_metadata_size=*/std::numeric_limits<size_t>::max() -
+ kMetadataHeaderSize);
+
+ EXPECT_FALSE(b3->IsValid());
+ EXPECT_TRUE(b3->buffer() == nullptr);
+}
+
+TEST_F(LibBufferHubTest, TestCreateDetachedBuffer) {
+ auto b1 = DetachedBuffer::Create(kWidth, kHeight, kLayerCount, kFormat,
+ kUsage, kUserMetadataSize);
+ int b1_id = b1->id();
+
+ EXPECT_TRUE(b1->IsValid());
+ ASSERT_TRUE(b1->buffer() != nullptr);
+ EXPECT_NE(b1->id(), 0);
+ EXPECT_EQ(b1->buffer()->initCheck(), 0);
+ EXPECT_FALSE(b1->buffer()->isDetachedBuffer());
+
+ // Takes a standalone GraphicBuffer which still holds on an
+ // PDX::LocalChannelHandle towards BufferHub.
+ sp<GraphicBuffer> g1 = b1->TakeGraphicBuffer();
+ ASSERT_TRUE(g1 != nullptr);
+ EXPECT_TRUE(g1->isDetachedBuffer());
+
+ EXPECT_FALSE(b1->IsValid());
+ EXPECT_TRUE(b1->buffer() == nullptr);
+
+ sp<GraphicBuffer> g2 = b1->TakeGraphicBuffer();
+ ASSERT_TRUE(g2 == nullptr);
+
+ auto h1 = g1->takeDetachedBufferHandle();
+ ASSERT_TRUE(h1 != nullptr);
+ ASSERT_TRUE(h1->isValid());
+ EXPECT_FALSE(g1->isDetachedBuffer());
+
+ auto b2 = DetachedBuffer::Import(std::move(h1->handle()));
+ ASSERT_FALSE(h1->isValid());
+ EXPECT_TRUE(b2->IsValid());
+
+ ASSERT_TRUE(b2->buffer() != nullptr);
+ EXPECT_EQ(b2->buffer()->initCheck(), 0);
+
+ // The newly created DetachedBuffer should share the original buffer_id.
+ EXPECT_EQ(b2->id(), b1_id);
+ EXPECT_FALSE(b2->buffer()->isDetachedBuffer());
}
diff --git a/libs/vr/libbufferhub/buffer_hub_client.cpp b/libs/vr/libbufferhub/buffer_hub_client.cpp
index 13971eb..159f2bd 100644
--- a/libs/vr/libbufferhub/buffer_hub_client.cpp
+++ b/libs/vr/libbufferhub/buffer_hub_client.cpp
@@ -15,10 +15,30 @@
using android::pdx::LocalChannelHandle;
using android::pdx::LocalHandle;
using android::pdx::Status;
+using android::pdx::default_transport::ClientChannel;
+using android::pdx::default_transport::ClientChannelFactory;
namespace android {
namespace dvr {
+BufferHubClient::BufferHubClient()
+ : Client(ClientChannelFactory::Create(BufferHubRPC::kClientPath)) {}
+
+BufferHubClient::BufferHubClient(LocalChannelHandle channel_handle)
+ : Client(ClientChannel::Create(std::move(channel_handle))) {}
+
+bool BufferHubClient::IsValid() const {
+ return IsConnected() && GetChannelHandle().valid();
+}
+
+LocalChannelHandle BufferHubClient::TakeChannelHandle() {
+ if (IsConnected()) {
+ return std::move(GetChannelHandle());
+ } else {
+ return {};
+ }
+}
+
BufferHubBuffer::BufferHubBuffer(LocalChannelHandle channel_handle)
: Client{pdx::default_transport::ClientChannel::Create(
std::move(channel_handle))},
diff --git a/libs/vr/libbufferhub/detached_buffer.cpp b/libs/vr/libbufferhub/detached_buffer.cpp
new file mode 100644
index 0000000..1d59cf3
--- /dev/null
+++ b/libs/vr/libbufferhub/detached_buffer.cpp
@@ -0,0 +1,104 @@
+#include <private/dvr/detached_buffer.h>
+
+#include <pdx/file_handle.h>
+#include <ui/DetachedBufferHandle.h>
+
+using android::pdx::LocalHandle;
+
+namespace android {
+namespace dvr {
+
+DetachedBuffer::DetachedBuffer(uint32_t width, uint32_t height,
+ uint32_t layer_count, uint32_t format,
+ uint64_t usage, size_t user_metadata_size) {
+ ATRACE_NAME("DetachedBuffer::DetachedBuffer");
+ ALOGD_IF(TRACE,
+ "DetachedBuffer::DetachedBuffer: width=%u height=%u layer_count=%u, "
+ "format=%u usage=%" PRIx64 " user_metadata_size=%zu",
+ width, height, layer_count, format, usage, user_metadata_size);
+
+ auto status = client_.InvokeRemoteMethod<DetachedBufferRPC::Create>(
+ width, height, layer_count, format, usage, user_metadata_size);
+ if (!status) {
+ ALOGE(
+ "DetachedBuffer::DetachedBuffer: Failed to create detached buffer: %s",
+ status.GetErrorMessage().c_str());
+ client_.Close(-status.error());
+ }
+
+ const int ret = ImportGraphicBuffer();
+ if (ret < 0) {
+ ALOGE("DetachedBuffer::DetachedBuffer: Failed to import buffer: %s",
+ strerror(-ret));
+ client_.Close(ret);
+ }
+}
+
+DetachedBuffer::DetachedBuffer(LocalChannelHandle channel_handle)
+ : client_(std::move(channel_handle)) {
+ const int ret = ImportGraphicBuffer();
+ if (ret < 0) {
+ ALOGE("DetachedBuffer::DetachedBuffer: Failed to import buffer: %s",
+ strerror(-ret));
+ client_.Close(ret);
+ }
+}
+
+int DetachedBuffer::ImportGraphicBuffer() {
+ ATRACE_NAME("DetachedBuffer::DetachedBuffer");
+
+ auto status = client_.InvokeRemoteMethod<DetachedBufferRPC::Import>();
+ if (!status) {
+ ALOGE("DetachedBuffer::DetachedBuffer: Failed to import GraphicBuffer: %s",
+ status.GetErrorMessage().c_str());
+ return -status.error();
+ }
+
+ BufferDescription<LocalHandle> buffer_desc = status.take();
+ if (buffer_desc.id() < 0) {
+ ALOGE("DetachedBuffer::DetachedBuffer: Received an invalid id!");
+ return -EIO;
+ }
+
+ // Stash the buffer id to replace the value in id_.
+ const int buffer_id = buffer_desc.id();
+
+ // Import the buffer.
+ IonBuffer ion_buffer;
+ ALOGD_IF(TRACE, "DetachedBuffer::DetachedBuffer: id=%d.", buffer_id);
+
+ if (const int ret = buffer_desc.ImportBuffer(&ion_buffer)) {
+ ALOGE("Failed to import GraphicBuffer, error=%d", ret);
+ return ret;
+ }
+
+ // If all imports succeed, replace the previous buffer and id.
+ id_ = buffer_id;
+ buffer_ = std::move(ion_buffer);
+ return 0;
+}
+
+std::unique_ptr<BufferProducer> DetachedBuffer::Promote() {
+ ALOGE("DetachedBuffer::Promote: Not implemented.");
+ return nullptr;
+}
+
+sp<GraphicBuffer> DetachedBuffer::TakeGraphicBuffer() {
+ if (!client_.IsValid() || !buffer_.buffer()) {
+ ALOGE("DetachedBuffer::TakeGraphicBuffer: Invalid buffer.");
+ return nullptr;
+ }
+
+ // Technically this should never happen.
+ LOG_FATAL_IF(
+ buffer_.buffer()->isDetachedBuffer(),
+ "DetachedBuffer::TakeGraphicBuffer: GraphicBuffer is already detached.");
+
+ sp<GraphicBuffer> buffer = std::move(buffer_.buffer());
+ buffer->setDetachedBufferHandle(
+ DetachedBufferHandle::Create(client_.TakeChannelHandle()));
+ return buffer;
+}
+
+} // namespace dvr
+} // namespace android
diff --git a/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h b/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h
index 32448a1..c1cc7f3 100644
--- a/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h
+++ b/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h
@@ -16,6 +16,21 @@
namespace android {
namespace dvr {
+class BufferHubClient : public pdx::Client {
+ public:
+ using LocalChannelHandle = pdx::LocalChannelHandle;
+
+ BufferHubClient();
+ explicit BufferHubClient(LocalChannelHandle channel_handle);
+
+ bool IsValid() const;
+ LocalChannelHandle TakeChannelHandle();
+
+ using pdx::Client::Close;
+ using pdx::Client::InvokeRemoteMethod;
+ using pdx::Client::IsConnected;
+};
+
class BufferHubBuffer : public pdx::Client {
public:
using LocalHandle = pdx::LocalHandle;
diff --git a/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h b/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h
index fabefd5..f4918c4 100644
--- a/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h
+++ b/libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h
@@ -375,7 +375,7 @@
kOpConsumerSetIgnore,
kOpProducerBufferDetach,
kOpConsumerBufferDetach,
- kOpCreateDetachedBuffer,
+ kOpDetachedBufferCreate,
kOpDetachedBufferPromote,
kOpCreateProducerQueue,
kOpCreateConsumerQueue,
@@ -383,6 +383,8 @@
kOpProducerQueueAllocateBuffers,
kOpProducerQueueRemoveBuffer,
kOpConsumerQueueImportBuffers,
+ // TODO(b/77153033): Separate all those RPC operations into subclasses.
+ kOpDetachedBufferBase = 1000,
};
// Aliases.
@@ -416,17 +418,6 @@
PDX_REMOTE_METHOD(ConsumerBufferDetach, kOpConsumerBufferDetach,
LocalChannelHandle(Void));
- // Creates a standalone DetachedBuffer not associated with any
- // producer/consumer set.
- PDX_REMOTE_METHOD(CreateDetachedBuffer, kOpCreateDetachedBuffer,
- LocalChannelHandle(Void));
-
- // Promotes a DetachedBuffer to become a ProducerBuffer. Once promoted the
- // DetachedBuffer channel will be closed automatically on successful IPC
- // return. Further IPCs towards this channel will return error.
- PDX_REMOTE_METHOD(DetachedBufferPromote, kOpDetachedBufferPromote,
- LocalChannelHandle(Void));
-
// Buffer Queue Methods.
PDX_REMOTE_METHOD(CreateProducerQueue, kOpCreateProducerQueue,
QueueInfo(const ProducerQueueConfig& producer_config,
@@ -445,6 +436,25 @@
std::vector<std::pair<LocalChannelHandle, size_t>>(Void));
};
+struct DetachedBufferRPC final : public BufferHubRPC {
+ private:
+ enum {
+ kOpCreate = kOpDetachedBufferBase,
+ kOpImport,
+ kOpPromote,
+ };
+
+ public:
+ PDX_REMOTE_METHOD(Create, kOpCreate,
+ void(uint32_t width, uint32_t height, uint32_t layer_count,
+ uint32_t format, uint64_t usage,
+ size_t user_metadata_size));
+ PDX_REMOTE_METHOD(Import, kOpImport, BufferDescription<LocalHandle>(Void));
+ PDX_REMOTE_METHOD(Promote, kOpPromote, LocalChannelHandle(Void));
+
+ PDX_REMOTE_API(API, Create, Promote);
+};
+
} // namespace dvr
} // namespace android
diff --git a/libs/vr/libbufferhub/include/private/dvr/detached_buffer.h b/libs/vr/libbufferhub/include/private/dvr/detached_buffer.h
new file mode 100644
index 0000000..73e895d
--- /dev/null
+++ b/libs/vr/libbufferhub/include/private/dvr/detached_buffer.h
@@ -0,0 +1,65 @@
+#ifndef ANDROID_DVR_DETACHED_BUFFER_H_
+#define ANDROID_DVR_DETACHED_BUFFER_H_
+
+#include <private/dvr/buffer_hub_client.h>
+
+namespace android {
+namespace dvr {
+
+class DetachedBuffer {
+ public:
+ using LocalChannelHandle = pdx::LocalChannelHandle;
+
+ // Allocates a standalone DetachedBuffer not associated with any producer
+ // consumer set.
+ static std::unique_ptr<DetachedBuffer> Create(uint32_t width, uint32_t height,
+ uint32_t layer_count,
+ uint32_t format, uint64_t usage,
+ size_t user_metadata_size) {
+ return std::unique_ptr<DetachedBuffer>(new DetachedBuffer(
+ width, height, layer_count, format, usage, user_metadata_size));
+ }
+
+ // Imports the given channel handle to a DetachedBuffer, taking ownership.
+ static std::unique_ptr<DetachedBuffer> Import(
+ LocalChannelHandle channel_handle) {
+ return std::unique_ptr<DetachedBuffer>(
+ new DetachedBuffer(std::move(channel_handle)));
+ }
+
+ DetachedBuffer(const DetachedBuffer&) = delete;
+ void operator=(const DetachedBuffer&) = delete;
+
+ const sp<GraphicBuffer>& buffer() const { return buffer_.buffer(); }
+
+ int id() const { return id_; }
+ bool IsValid() const { return client_.IsValid(); }
+
+ // Promotes a DetachedBuffer to become a ProducerBuffer. Once promoted the
+ // DetachedBuffer channel will be closed automatically on successful IPC
+ // return. Further IPCs towards this channel will return error.
+ std::unique_ptr<BufferProducer> Promote();
+
+ // Takes the underlying graphic buffer out of this DetachedBuffer. This call
+ // immediately invalidates this DetachedBuffer object and transfers the
+ // underlying pdx::LocalChannelHandle into the GraphicBuffer.
+ sp<GraphicBuffer> TakeGraphicBuffer();
+
+ private:
+ DetachedBuffer(uint32_t width, uint32_t height, uint32_t layer_count,
+ uint32_t format, uint64_t usage, size_t user_metadata_size);
+
+ DetachedBuffer(LocalChannelHandle channel_handle);
+
+ int ImportGraphicBuffer();
+
+ // Global id for the buffer that is consistent across processes.
+ int id_;
+ IonBuffer buffer_;
+ BufferHubClient client_;
+};
+
+} // namespace dvr
+} // namespace android
+
+#endif // ANDROID_DVR_DETACHED_BUFFER_H_
diff --git a/libs/vr/libbufferhub/include/private/dvr/ion_buffer.h b/libs/vr/libbufferhub/include/private/dvr/ion_buffer.h
index 0d337f7..f6bc547 100644
--- a/libs/vr/libbufferhub/include/private/dvr/ion_buffer.h
+++ b/libs/vr/libbufferhub/include/private/dvr/ion_buffer.h
@@ -23,6 +23,9 @@
IonBuffer(IonBuffer&& other);
IonBuffer& operator=(IonBuffer&& other);
+ // Returns check this IonBuffer holds a valid Gralloc buffer.
+ bool IsValid() const { return buffer_ && buffer_->initCheck() == NO_ERROR; }
+
// Frees the underlying native handle and leaves the instance initialized to
// empty.
void FreeHandle();
@@ -66,6 +69,7 @@
struct android_ycbcr* yuv);
int Unlock();
+ sp<GraphicBuffer>& buffer() { return buffer_; }
const sp<GraphicBuffer>& buffer() const { return buffer_; }
buffer_handle_t handle() const {
return buffer_.get() ? buffer_->handle : nullptr;
diff --git a/libs/vr/libpdx/client.cpp b/libs/vr/libpdx/client.cpp
index a01c4d6..3c66a40 100644
--- a/libs/vr/libpdx/client.cpp
+++ b/libs/vr/libpdx/client.cpp
@@ -119,6 +119,10 @@
return channel_->GetChannelHandle();
}
+const LocalChannelHandle& Client::GetChannelHandle() const {
+ return channel_->GetChannelHandle();
+}
+
///////////////////////////// Transaction implementation //////////////////////
Transaction::Transaction(Client& client) : client_{client} {}
diff --git a/libs/vr/libpdx/private/pdx/client.h b/libs/vr/libpdx/private/pdx/client.h
index 656de7e..c35dabd 100644
--- a/libs/vr/libpdx/private/pdx/client.h
+++ b/libs/vr/libpdx/private/pdx/client.h
@@ -49,6 +49,7 @@
// Returns a reference to IPC channel handle.
LocalChannelHandle& GetChannelHandle();
+ const LocalChannelHandle& GetChannelHandle() const;
protected:
friend Transaction;
diff --git a/libs/vr/libpdx/private/pdx/client_channel.h b/libs/vr/libpdx/private/pdx/client_channel.h
index 8f5fdfe..f33a60e 100644
--- a/libs/vr/libpdx/private/pdx/client_channel.h
+++ b/libs/vr/libpdx/private/pdx/client_channel.h
@@ -33,6 +33,7 @@
virtual std::vector<EventSource> GetEventSources() const = 0;
virtual LocalChannelHandle& GetChannelHandle() = 0;
+ virtual const LocalChannelHandle& GetChannelHandle() const = 0;
virtual void* AllocateTransactionState() = 0;
virtual void FreeTransactionState(void* state) = 0;
diff --git a/libs/vr/libpdx/private/pdx/mock_client_channel.h b/libs/vr/libpdx/private/pdx/mock_client_channel.h
index ecc20b3..b1a1299 100644
--- a/libs/vr/libpdx/private/pdx/mock_client_channel.h
+++ b/libs/vr/libpdx/private/pdx/mock_client_channel.h
@@ -14,6 +14,7 @@
MOCK_CONST_METHOD0(GetEventSources, std::vector<EventSource>());
MOCK_METHOD1(GetEventMask, Status<int>(int));
MOCK_METHOD0(GetChannelHandle, LocalChannelHandle&());
+ MOCK_CONST_METHOD0(GetChannelHandle, const LocalChannelHandle&());
MOCK_METHOD0(AllocateTransactionState, void*());
MOCK_METHOD1(FreeTransactionState, void(void* state));
MOCK_METHOD3(SendImpulse,
diff --git a/libs/vr/libpdx_uds/private/uds/client_channel.h b/libs/vr/libpdx_uds/private/uds/client_channel.h
index b5524d8..3561c6f 100644
--- a/libs/vr/libpdx_uds/private/uds/client_channel.h
+++ b/libs/vr/libpdx_uds/private/uds/client_channel.h
@@ -41,6 +41,9 @@
}
LocalChannelHandle& GetChannelHandle() override { return channel_handle_; }
+ const LocalChannelHandle& GetChannelHandle() const override {
+ return channel_handle_;
+ }
void* AllocateTransactionState() override;
void FreeTransactionState(void* state) override;
diff --git a/opengl/libs/EGL/getProcAddress.cpp b/opengl/libs/EGL/getProcAddress.cpp
index c05e840..0183621 100644
--- a/opengl/libs/EGL/getProcAddress.cpp
+++ b/opengl/libs/EGL/getProcAddress.cpp
@@ -54,7 +54,7 @@
: [tls] "J"(TLS_SLOT_OPENGL_API*4), \
[ext] "J"(__builtin_offsetof(gl_hooks_t, \
ext.extensions[0])), \
- [api] "J"(_api*sizeof(void*)) \
+ [api] "I"(_api*sizeof(void*)) \
: "r12" \
);
diff --git a/opengl/libs/libGLESv2.map.txt b/opengl/libs/libGLESv2.map.txt
index 1b0042a..787c835 100644
--- a/opengl/libs/libGLESv2.map.txt
+++ b/opengl/libs/libGLESv2.map.txt
@@ -79,6 +79,7 @@
glFramebufferRenderbuffer;
glFramebufferTexture2D;
glFramebufferTexture2DMultisampleIMG; # introduced-mips=9 introduced-x86=9
+ glFramebufferTexture2DMultisampleEXT; # introduced=28
glFramebufferTexture3DOES;
glFrontFace;
glGenBuffers;
@@ -147,6 +148,7 @@
glReadPixels;
glReleaseShaderCompiler;
glRenderbufferStorage;
+ glRenderbufferStorageMultisampleEXT; # introduced=28
glRenderbufferStorageMultisampleIMG; # introduced-mips=9 introduced-x86=9
glSampleCoverage;
glScissor;
diff --git a/opengl/libs/libGLESv3.map.txt b/opengl/libs/libGLESv3.map.txt
index 21f6cb6..a7b17f4 100644
--- a/opengl/libs/libGLESv3.map.txt
+++ b/opengl/libs/libGLESv3.map.txt
@@ -36,6 +36,8 @@
glBlendFunciEXT; # introduced=21
glBlitFramebuffer;
glBufferData;
+ glBufferStorageEXT; # introduced=28
+ glBufferStorageExternalEXT; # introduced=28
glBufferSubData;
glCheckFramebufferStatus;
glClear;
@@ -110,6 +112,7 @@
glDrawRangeElementsBaseVertex; # introduced=24
glEGLImageTargetRenderbufferStorageOES;
glEGLImageTargetTexture2DOES;
+ glEGLImageTargetTexStorageEXT; # introduced=28
glEnable;
glEnableVertexAttribArray;
glEnablei; # introduced=24
@@ -124,9 +127,12 @@
glFramebufferRenderbuffer;
glFramebufferTexture; # introduced=24
glFramebufferTexture2D;
+ glFramebufferTexture2DMultisampleEXT; # introduced=28
glFramebufferTexture3DOES;
glFramebufferTextureEXT; # introduced=21
glFramebufferTextureLayer;
+ glFramebufferTextureMultisampleMultiviewOVR; # introduced=28
+ glFramebufferTextureMultiviewOVR; # introduced=28
glFrontFace;
glGenBuffers;
glGenFramebuffers;
@@ -306,6 +312,7 @@
glReleaseShaderCompiler;
glRenderbufferStorage;
glRenderbufferStorageMultisample;
+ glRenderbufferStorageMultisampleEXT; # introduced=28
glResumeTransformFeedback;
glSampleCoverage;
glSampleMaski; # introduced=21
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
index bbffd0a..5daa87e 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -350,15 +350,29 @@
std::vector<ColorMode>* outModes)
{
Error error = kDefaultError;
- mClient->getColorModes(display,
- [&](const auto& tmpError, const auto& tmpModes) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
- *outModes = tmpModes;
- });
+ if (mClient_2_2) {
+ mClient_2_2->getColorModes_2_2(display,
+ [&](const auto& tmpError, const auto& tmpModes) {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+
+ *outModes = tmpModes;
+ });
+ } else {
+ mClient->getColorModes(display,
+ [&](const auto& tmpError, const auto& tmpModes) {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+ for (V1_0::ColorMode colorMode : tmpModes) {
+ outModes->push_back(static_cast<ColorMode>(colorMode));
+ }
+ });
+ }
return error;
}
@@ -479,25 +493,6 @@
return error;
}
-Error Composer::getPerFrameMetadataKeys(
- Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) {
- if (!mClient_2_2) {
- return Error::UNSUPPORTED;
- }
-
- Error error = kDefaultError;
- mClient_2_2->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
-
- *outKeys = tmpKeys;
- });
-
- return error;
-}
-
Error Composer::getReleaseFences(Display display,
std::vector<Layer>* outLayers, std::vector<int>* outReleaseFences)
{
@@ -553,9 +548,16 @@
return Error::NONE;
}
-Error Composer::setColorMode(Display display, ColorMode mode)
+Error Composer::setColorMode(Display display, ColorMode mode,
+ RenderIntent renderIntent)
{
- auto ret = mClient->setColorMode(display, mode);
+ hardware::Return<Error> ret(kDefaultError);
+ if (mClient_2_2) {
+ ret = mClient_2_2->setColorMode_2_2(display, mode, renderIntent);
+ } else {
+ ret = mClient->setColorMode(display,
+ static_cast<V1_0::ColorMode>(mode));
+ }
return unwrapRet(ret);
}
@@ -862,39 +864,44 @@
}
Error error = kDefaultError;
- auto ret = mClient->executeCommands(commandLength, commandHandles,
- [&](const auto& tmpError, const auto& tmpOutChanged,
- const auto& tmpOutLength, const auto& tmpOutHandles)
- {
- error = tmpError;
+ hardware::Return<void> ret;
+ auto hidl_callback = [&](const auto& tmpError, const auto& tmpOutChanged,
+ const auto& tmpOutLength, const auto& tmpOutHandles)
+ {
+ error = tmpError;
- // set up new output command queue if necessary
- if (error == Error::NONE && tmpOutChanged) {
- error = kDefaultError;
- mClient->getOutputCommandQueue(
- [&](const auto& tmpError,
- const auto& tmpDescriptor)
- {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
+ // set up new output command queue if necessary
+ if (error == Error::NONE && tmpOutChanged) {
+ error = kDefaultError;
+ mClient->getOutputCommandQueue(
+ [&](const auto& tmpError,
+ const auto& tmpDescriptor)
+ {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
- mReader.setMQDescriptor(tmpDescriptor);
- });
- }
+ mReader.setMQDescriptor(tmpDescriptor);
+ });
+ }
- if (error != Error::NONE) {
- return;
- }
+ if (error != Error::NONE) {
+ return;
+ }
- if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
- error = mReader.parse();
- mReader.reset();
- } else {
- error = Error::NO_RESOURCES;
- }
- });
+ if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
+ error = mReader.parse();
+ mReader.reset();
+ } else {
+ error = Error::NO_RESOURCES;
+ }
+ };
+ if (mClient_2_2) {
+ ret = mClient_2_2->executeCommands_2_2(commandLength, commandHandles, hidl_callback);
+ } else {
+ ret = mClient->executeCommands(commandLength, commandHandles, hidl_callback);
+ }
// executeCommands can fail because of out-of-fd and we do not want to
// abort() in that case
if (!ret.isOk()) {
@@ -925,6 +932,68 @@
return error;
}
+// Composer HAL 2.2
+
+Error Composer::getPerFrameMetadataKeys(
+ Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) {
+ if (!mClient_2_2) {
+ return Error::UNSUPPORTED;
+ }
+
+ Error error = kDefaultError;
+ mClient_2_2->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+
+ *outKeys = tmpKeys;
+ });
+
+ return error;
+}
+
+Error Composer::getRenderIntents(Display display, ColorMode colorMode,
+ std::vector<RenderIntent>* outRenderIntents) {
+ if (!mClient_2_2) {
+ outRenderIntents->push_back(RenderIntent::COLORIMETRIC);
+ return Error::NONE;
+ }
+
+ Error error = kDefaultError;
+ mClient_2_2->getRenderIntents(display, colorMode,
+ [&](const auto& tmpError, const auto& tmpKeys) {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+
+ *outRenderIntents = tmpKeys;
+ });
+
+ return error;
+}
+
+Error Composer::getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix)
+{
+ if (!mClient_2_2) {
+ *outMatrix = mat4();
+ return Error::NONE;
+ }
+
+ Error error = kDefaultError;
+ mClient_2_2->getDataspaceSaturationMatrix(dataspace, [&](const auto& tmpError, const auto& tmpMatrix) {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+
+ *outMatrix = mat4(tmpMatrix.data());
+ });
+
+ return error;
+}
+
CommandReader::~CommandReader()
{
resetData();
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h
index 98f2f9d..08901f6 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.h
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h
@@ -29,6 +29,7 @@
#include <android/hardware/graphics/composer/2.2/IComposerClient.h>
#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
#include <gui/HdrMetadata.h>
+#include <math/mat4.h>
#include <ui/GraphicBuffer.h>
#include <utils/StrongPointer.h>
@@ -38,12 +39,13 @@
using android::frameworks::vr::composer::V1_0::IVrComposerClient;
-using android::hardware::graphics::common::V1_0::ColorMode;
using android::hardware::graphics::common::V1_0::ColorTransform;
using android::hardware::graphics::common::V1_0::Hdr;
using android::hardware::graphics::common::V1_0::Transform;
+using android::hardware::graphics::common::V1_1::ColorMode;
using android::hardware::graphics::common::V1_1::Dataspace;
using android::hardware::graphics::common::V1_1::PixelFormat;
+using android::hardware::graphics::common::V1_1::RenderIntent;
using android::hardware::graphics::composer::V2_1::Config;
using android::hardware::graphics::composer::V2_1::Display;
@@ -114,9 +116,6 @@
float* outMaxLuminance, float* outMaxAverageLuminance,
float* outMinLuminance) = 0;
- virtual Error getPerFrameMetadataKeys(
- Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) = 0;
-
virtual Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
std::vector<int>* outReleaseFences) = 0;
@@ -132,7 +131,7 @@
virtual Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
int acquireFence, Dataspace dataspace,
const std::vector<IComposerClient::Rect>& damage) = 0;
- virtual Error setColorMode(Display display, ColorMode mode) = 0;
+ virtual Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) = 0;
virtual Error setColorTransform(Display display, const float* matrix, ColorTransform hint) = 0;
virtual Error setOutputBuffer(Display display, const native_handle_t* buffer,
int releaseFence) = 0;
@@ -175,6 +174,13 @@
const std::vector<IComposerClient::Rect>& visible) = 0;
virtual Error setLayerZOrder(Display display, Layer layer, uint32_t z) = 0;
virtual Error setLayerInfo(Display display, Layer layer, uint32_t type, uint32_t appId) = 0;
+
+ // Composer HAL 2.2
+ virtual Error getPerFrameMetadataKeys(
+ Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) = 0;
+ virtual Error getRenderIntents(Display display, ColorMode colorMode,
+ std::vector<RenderIntent>* outRenderIntents) = 0;
+ virtual Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) = 0;
};
namespace impl {
@@ -306,9 +312,6 @@
Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes, float* outMaxLuminance,
float* outMaxAverageLuminance, float* outMinLuminance) override;
- Error getPerFrameMetadataKeys(
- Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) override;
-
Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
std::vector<int>* outReleaseFences) override;
@@ -324,7 +327,7 @@
Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
int acquireFence, Dataspace dataspace,
const std::vector<IComposerClient::Rect>& damage) override;
- Error setColorMode(Display display, ColorMode mode) override;
+ Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
Error setColorTransform(Display display, const float* matrix, ColorTransform hint) override;
Error setOutputBuffer(Display display, const native_handle_t* buffer,
int releaseFence) override;
@@ -364,6 +367,13 @@
Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
Error setLayerInfo(Display display, Layer layer, uint32_t type, uint32_t appId) override;
+ // Composer HAL 2.2
+ Error getPerFrameMetadataKeys(
+ Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) override;
+ Error getRenderIntents(Display display, ColorMode colorMode,
+ std::vector<RenderIntent>* outRenderIntents) override;
+ Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;
+
private:
class CommandWriter : public CommandWriterBase {
public:
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.cpp b/services/surfaceflinger/DisplayHardware/HWC2.cpp
index 2686788..5f94bb4 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp
@@ -50,6 +50,7 @@
using android::ui::ColorMode;
using android::ui::Dataspace;
using android::ui::PixelFormat;
+using android::ui::RenderIntent;
namespace {
@@ -369,6 +370,19 @@
return static_cast<Error>(intError);
}
+Error Display::getRenderIntents(ColorMode colorMode,
+ std::vector<RenderIntent>* outRenderIntents) const
+{
+ auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
+ return static_cast<Error>(intError);
+}
+
+Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
+{
+ auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
+ return static_cast<Error>(intError);
+}
+
std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
{
std::vector<std::shared_ptr<const Config>> configs;
@@ -526,9 +540,9 @@
return static_cast<Error>(intError);
}
-Error Display::setColorMode(ColorMode mode)
+Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
{
- auto intError = mComposer.setColorMode(mId, mode);
+ auto intError = mComposer.setColorMode(mId, mode, renderIntent);
return static_cast<Error>(intError);
}
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.h b/services/surfaceflinger/DisplayHardware/HWC2.h
index 9b870e3..e5779d4 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.h
+++ b/services/surfaceflinger/DisplayHardware/HWC2.h
@@ -212,6 +212,11 @@
std::unordered_map<Layer*, Composition>* outTypes);
[[clang::warn_unused_result]] Error getColorModes(
std::vector<android::ui::ColorMode>* outModes) const;
+ [[clang::warn_unused_result]] Error getRenderIntents(
+ android::ui::ColorMode colorMode,
+ std::vector<android::ui::RenderIntent>* outRenderIntents) const;
+ [[clang::warn_unused_result]] Error getDataspaceSaturationMatrix(
+ android::ui::Dataspace dataspace, android::mat4* outMatrix);
// Doesn't call into the HWC2 device, so no errors are possible
std::vector<std::shared_ptr<const Config>> getConfigs() const;
@@ -236,7 +241,8 @@
const android::sp<android::Fence>& acquireFence,
android::ui::Dataspace dataspace);
[[clang::warn_unused_result]] Error setColorMode(
- android::ui::ColorMode mode);
+ android::ui::ColorMode mode,
+ android::ui::RenderIntent renderIntent);
[[clang::warn_unused_result]] Error setColorTransform(
const android::mat4& matrix, android_color_transform_t hint);
[[clang::warn_unused_result]] Error setOutputBuffer(
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index 29e2727..8db8aa6 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -330,17 +330,20 @@
return modes;
}
-status_t HWComposer::setActiveColorMode(int32_t displayId, ui::ColorMode mode) {
+status_t HWComposer::setActiveColorMode(int32_t displayId, ui::ColorMode mode,
+ ui::RenderIntent renderIntent) {
if (!isValidDisplay(displayId)) {
ALOGE("setActiveColorMode: Display %d is not valid", displayId);
return BAD_INDEX;
}
auto& displayData = mDisplayData[displayId];
- auto error = displayData.hwcDisplay->setColorMode(mode);
+ auto error = displayData.hwcDisplay->setColorMode(mode, renderIntent);
if (error != HWC2::Error::None) {
- ALOGE("setActiveConfig: Failed to set color mode %d on display %d: "
- "%s (%d)", mode, displayId, to_string(error).c_str(),
+ ALOGE("setActiveConfig: Failed to set color mode %d"
+ "with render intent %d on display %d: "
+ "%s (%d)", mode, renderIntent, displayId,
+ to_string(error).c_str(),
static_cast<int32_t>(error));
return UNKNOWN_ERROR;
}
@@ -841,6 +844,44 @@
return capabilities;
}
+std::vector<ui::RenderIntent> HWComposer::getRenderIntents(int32_t displayId,
+ ui::ColorMode colorMode) const {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("getRenderIntents: Attempted to access invalid display %d",
+ displayId);
+ return {};
+ }
+
+ std::vector<ui::RenderIntent> renderIntents;
+ auto error = mDisplayData[displayId].hwcDisplay->getRenderIntents(colorMode, &renderIntents);
+ if (error != HWC2::Error::None) {
+ ALOGE("getColorModes failed for display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return std::vector<ui::RenderIntent>();
+ }
+
+ return renderIntents;
+}
+
+mat4 HWComposer::getDataspaceSaturationMatrix(int32_t displayId, ui::Dataspace dataspace) {
+ if (!isValidDisplay(displayId)) {
+ ALOGE("getDataSpaceSaturationMatrix: Attempted to access invalid display %d",
+ displayId);
+ return {};
+ }
+
+ mat4 matrix;
+ auto error = mDisplayData[displayId].hwcDisplay->getDataspaceSaturationMatrix(dataspace,
+ &matrix);
+ if (error != HWC2::Error::None) {
+ ALOGE("getDataSpaceSaturationMatrix failed for display %d: %s (%d)", displayId,
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ return mat4();
+ }
+
+ return matrix;
+}
+
// Converts a PixelFormat to a human-readable string. Max 11 chars.
// (Could use a table of prefab String8 objects.)
/*
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 6e2e156..e86d621 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -137,6 +137,11 @@
// Returns the HDR capabilities of the given display
std::unique_ptr<HdrCapabilities> getHdrCapabilities(int32_t displayId);
+ // Returns the available RenderIntent of the given display.
+ std::vector<ui::RenderIntent> getRenderIntents(int32_t displayId, ui::ColorMode colorMode) const;
+
+ mat4 getDataspaceSaturationMatrix(int32_t displayId, ui::Dataspace dataspace);
+
// Events handling ---------------------------------------------------------
// Returns true if successful, false otherwise. The
@@ -161,7 +166,8 @@
std::vector<ui::ColorMode> getColorModes(int32_t displayId) const;
- status_t setActiveColorMode(int32_t displayId, ui::ColorMode mode);
+ status_t setActiveColorMode(int32_t displayId, ui::ColorMode mode,
+ ui::RenderIntent renderIntent);
bool isUsingVrComposer() const;
diff --git a/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp b/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp
index 1eda900..1fc3100 100644
--- a/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp
+++ b/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp
@@ -302,6 +302,7 @@
glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
mesh.getByteStride(), mesh.getPositions());
+ // TODO(b/73825729) Refactor this code block to handle BT2020 color space properly.
// DISPLAY_P3 is the only supported wide color output
if (mPlatformHasWideColor && mOutputDataSpace == Dataspace::DISPLAY_P3) {
Description wideColorState = mState;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index bf76ef5..5be7951 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -106,6 +106,7 @@
using namespace android::hardware::configstore::V1_0;
using ui::ColorMode;
using ui::Dataspace;
+using ui::RenderIntent;
namespace {
class ConditionalLock {
@@ -1007,7 +1008,7 @@
hw->getDisplayType());
hw->setActiveColorMode(mode);
- getHwComposer().setActiveColorMode(type, mode);
+ getHwComposer().setActiveColorMode(type, mode, RenderIntent::COLORIMETRIC);
}
@@ -4532,6 +4533,11 @@
void SurfaceFlinger::repaintEverythingLocked() {
android_atomic_or(1, &mRepaintEverything);
+ for (size_t dpy = 0; dpy < mDisplays.size(); dpy++) {
+ const sp<DisplayDevice>& displayDevice(mDisplays[dpy]);
+ const Rect bounds(displayDevice->getBounds());
+ displayDevice->dirtyRegion.orSelf(Region(bounds));
+ }
signalTransaction();
}
diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
index c048c58..0705b5c 100644
--- a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
@@ -46,8 +46,8 @@
using testing::Return;
using testing::SetArgPointee;
-using android::hardware::graphics::common::V1_0::ColorMode;
using android::hardware::graphics::common::V1_0::Hdr;
+using android::hardware::graphics::common::V1_1::ColorMode;
using android::Hwc2::Error;
using android::Hwc2::IComposer;
using android::Hwc2::IComposerClient;
diff --git a/services/surfaceflinger/tests/unittests/MockComposer.h b/services/surfaceflinger/tests/unittests/MockComposer.h
index 00e565b..8be2779 100644
--- a/services/surfaceflinger/tests/unittests/MockComposer.h
+++ b/services/surfaceflinger/tests/unittests/MockComposer.h
@@ -27,12 +27,13 @@
namespace Hwc2 {
namespace mock {
-using android::hardware::graphics::common::V1_0::ColorMode;
using android::hardware::graphics::common::V1_0::ColorTransform;
using android::hardware::graphics::common::V1_0::Hdr;
using android::hardware::graphics::common::V1_0::Transform;
+using android::hardware::graphics::common::V1_1::ColorMode;
using android::hardware::graphics::common::V1_1::Dataspace;
using android::hardware::graphics::common::V1_1::PixelFormat;
+using android::hardware::graphics::common::V1_1::RenderIntent;
using android::hardware::graphics::composer::V2_1::Config;
using android::hardware::graphics::composer::V2_1::Display;
@@ -75,13 +76,14 @@
MOCK_METHOD5(getHdrCapabilities, Error(Display, std::vector<Hdr>*, float*, float*, float*));
MOCK_METHOD2(getPerFrameMetadataKeys,
Error(Display, std::vector<IComposerClient::PerFrameMetadataKey>*));
+ MOCK_METHOD2(getDataspaceSaturationMatrix, Error(Dataspace, mat4*));
MOCK_METHOD3(getReleaseFences, Error(Display, std::vector<Layer>*, std::vector<int>*));
MOCK_METHOD2(presentDisplay, Error(Display, int*));
MOCK_METHOD2(setActiveConfig, Error(Display, Config));
MOCK_METHOD6(setClientTarget,
Error(Display, uint32_t, const sp<GraphicBuffer>&, int, Dataspace,
const std::vector<IComposerClient::Rect>&));
- MOCK_METHOD2(setColorMode, Error(Display, ColorMode));
+ MOCK_METHOD3(setColorMode, Error(Display, ColorMode, RenderIntent));
MOCK_METHOD3(setColorTransform, Error(Display, const float*, ColorTransform));
MOCK_METHOD3(setOutputBuffer, Error(Display, const native_handle_t*, int));
MOCK_METHOD2(setPowerMode, Error(Display, IComposerClient::PowerMode));
@@ -107,6 +109,7 @@
Error(Display, Layer, const std::vector<IComposerClient::Rect>&));
MOCK_METHOD3(setLayerZOrder, Error(Display, Layer, uint32_t));
MOCK_METHOD4(setLayerInfo, Error(Display, Layer, uint32_t, uint32_t));
+ MOCK_METHOD3(getRenderIntents, Error(Display, ColorMode, std::vector<RenderIntent>*));
};
} // namespace mock
diff --git a/services/vr/bufferhubd/buffer_hub.cpp b/services/vr/bufferhubd/buffer_hub.cpp
index e4e19c7..72bf6f2 100644
--- a/services/vr/bufferhubd/buffer_hub.cpp
+++ b/services/vr/bufferhubd/buffer_hub.cpp
@@ -6,6 +6,7 @@
#include <utils/Trace.h>
#include <iomanip>
+#include <memory>
#include <sstream>
#include <string>
#include <thread>
@@ -13,6 +14,7 @@
#include <pdx/default_transport/service_endpoint.h>
#include <private/dvr/bufferhub_rpc.h>
#include "consumer_channel.h"
+#include "detached_buffer_channel.h"
#include "producer_channel.h"
#include "producer_queue_channel.h"
@@ -245,6 +247,11 @@
*this, &BufferHubService::OnCreateBuffer, message);
return {};
+ case DetachedBufferRPC::Create::Opcode:
+ DispatchRemoteMethod<DetachedBufferRPC::Create>(
+ *this, &BufferHubService::OnCreateDetachedBuffer, message);
+ return {};
+
case BufferHubRPC::CreateProducerQueue::Opcode:
DispatchRemoteMethod<BufferHubRPC::CreateProducerQueue>(
*this, &BufferHubService::OnCreateProducerQueue, message);
@@ -295,6 +302,43 @@
}
}
+pdx::Status<void> BufferHubService::OnCreateDetachedBuffer(
+ pdx::Message& message, uint32_t width, uint32_t height,
+ uint32_t layer_count, uint32_t format, uint64_t usage,
+ size_t user_metadata_size) {
+ // Use the producer channel id as the global buffer id.
+ const int buffer_id = message.GetChannelId();
+ ALOGD_IF(TRACE,
+ "BufferHubService::OnCreateDetachedBuffer: buffer_id=%d width=%u "
+ "height=%u layer_count=%u format=%u usage=%" PRIx64
+ " user_metadata_size=%zu",
+ buffer_id, width, height, layer_count, format, usage,
+ user_metadata_size);
+
+ // See if this channel is already attached to a buffer.
+ if (const auto channel = message.GetChannel<BufferHubChannel>()) {
+ ALOGE(
+ "BufferHubService::OnCreateDetachedBuffer: Buffer already created: "
+ "buffer=%d",
+ buffer_id);
+ return ErrorStatus(EALREADY);
+ }
+
+ std::unique_ptr<DetachedBufferChannel> channel =
+ DetachedBufferChannel::Create(this, buffer_id, width, height, layer_count,
+ format, usage, user_metadata_size);
+ if (!channel) {
+ ALOGE(
+ "BufferHubService::OnCreateDetachedBuffer: Failed to allocate buffer, "
+ "buffer=%d.",
+ buffer_id);
+ return ErrorStatus(ENOMEM);
+ }
+
+ message.SetChannel(std::move(channel));
+ return {};
+}
+
Status<QueueInfo> BufferHubService::OnCreateProducerQueue(
pdx::Message& message, const ProducerQueueConfig& producer_config,
const UsagePolicy& usage_policy) {
diff --git a/services/vr/bufferhubd/buffer_hub.h b/services/vr/bufferhubd/buffer_hub.h
index e04967a..e47ffa3 100644
--- a/services/vr/bufferhubd/buffer_hub.h
+++ b/services/vr/bufferhubd/buffer_hub.h
@@ -147,6 +147,11 @@
pdx::Status<void> OnCreateBuffer(pdx::Message& message, uint32_t width,
uint32_t height, uint32_t format,
uint64_t usage, size_t meta_size_bytes);
+ pdx::Status<void> OnCreateDetachedBuffer(pdx::Message& message,
+ uint32_t width, uint32_t height,
+ uint32_t layer_count,
+ uint32_t format, uint64_t usage,
+ size_t user_metadata_size);
pdx::Status<QueueInfo> OnCreateProducerQueue(
pdx::Message& message, const ProducerQueueConfig& producer_config,
const UsagePolicy& usage_policy);
diff --git a/services/vr/bufferhubd/detached_buffer_channel.cpp b/services/vr/bufferhubd/detached_buffer_channel.cpp
index edb2111..4f4160a 100644
--- a/services/vr/bufferhubd/detached_buffer_channel.cpp
+++ b/services/vr/bufferhubd/detached_buffer_channel.cpp
@@ -1,5 +1,6 @@
#include "detached_buffer_channel.h"
+using android::pdx::BorrowedHandle;
using android::pdx::ErrorStatus;
using android::pdx::Message;
using android::pdx::RemoteChannelHandle;
@@ -17,7 +18,49 @@
: BufferHubChannel(service, buffer_id, channel_id, kDetachedBufferType),
buffer_(std::move(buffer)),
metadata_buffer_(std::move(metadata_buffer)),
- user_metadata_size_(user_metadata_size) {}
+ user_metadata_size_(user_metadata_size) {
+}
+
+DetachedBufferChannel::DetachedBufferChannel(BufferHubService* service,
+ int buffer_id, uint32_t width,
+ uint32_t height,
+ uint32_t layer_count,
+ uint32_t format, uint64_t usage,
+ size_t user_metadata_size)
+ : BufferHubChannel(service, buffer_id, buffer_id, kDetachedBufferType),
+ user_metadata_size_(user_metadata_size) {
+ // The size the of metadata buffer is used as the "width" parameter during
+ // allocation. Thus it cannot overflow uint32_t.
+ if (user_metadata_size_ >= (std::numeric_limits<uint32_t>::max() -
+ BufferHubDefs::kMetadataHeaderSize)) {
+ ALOGE(
+ "DetachedBufferChannel::DetachedBufferChannel: metadata size too big.");
+ return;
+ }
+
+ if (int ret = buffer_.Alloc(width, height, layer_count, format, usage)) {
+ ALOGE(
+ "DetachedBufferChannel::DetachedBufferChannel: Failed to allocate "
+ "buffer: %s",
+ strerror(-ret));
+ return;
+ }
+
+ // Buffer metadata has two parts: 1) a fixed sized metadata header; and 2)
+ // user requested metadata.
+ const size_t size = BufferHubDefs::kMetadataHeaderSize + user_metadata_size_;
+ if (int ret = metadata_buffer_.Alloc(size,
+ /*height=*/1,
+ /*layer_count=*/1,
+ BufferHubDefs::kMetadataFormat,
+ BufferHubDefs::kMetadataUsage)) {
+ ALOGE(
+ "DetachedBufferChannel::DetachedBufferChannel: Failed to allocate "
+ "metadata: %s",
+ strerror(-ret));
+ return;
+ }
+}
BufferHubChannel::BufferInfo DetachedBufferChannel::GetBufferInfo() const {
return BufferInfo(buffer_id(), /*consumer_count=*/0, buffer_.width(),
@@ -33,8 +76,13 @@
bool DetachedBufferChannel::HandleMessage(Message& message) {
ATRACE_NAME("DetachedBufferChannel::HandleMessage");
switch (message.GetOp()) {
- case BufferHubRPC::DetachedBufferPromote::Opcode:
- DispatchRemoteMethod<BufferHubRPC::DetachedBufferPromote>(
+ case DetachedBufferRPC::Import::Opcode:
+ DispatchRemoteMethod<DetachedBufferRPC::Import>(
+ *this, &DetachedBufferChannel::OnImport, message);
+ return true;
+
+ case DetachedBufferRPC::Promote::Opcode:
+ DispatchRemoteMethod<DetachedBufferRPC::Promote>(
*this, &DetachedBufferChannel::OnPromote, message);
return true;
@@ -43,6 +91,20 @@
}
}
+Status<BufferDescription<BorrowedHandle>> DetachedBufferChannel::OnImport(
+ Message& /*message*/) {
+ ATRACE_NAME("DetachedBufferChannel::OnGetBuffer");
+ ALOGD_IF(TRACE, "DetachedBufferChannel::OnGetBuffer: buffer=%d.",
+ buffer_id());
+
+ return BufferDescription<BorrowedHandle>{buffer_,
+ metadata_buffer_,
+ buffer_id(),
+ /*buffer_state_bit=*/0,
+ BorrowedHandle{},
+ BorrowedHandle{}};
+}
+
Status<RemoteChannelHandle> DetachedBufferChannel::OnPromote(
Message& /*message*/) {
ATRACE_NAME("DetachedBufferChannel::OnPromote");
diff --git a/services/vr/bufferhubd/detached_buffer_channel.h b/services/vr/bufferhubd/detached_buffer_channel.h
index 7ce4aed..079ba72 100644
--- a/services/vr/bufferhubd/detached_buffer_channel.h
+++ b/services/vr/bufferhubd/detached_buffer_channel.h
@@ -3,20 +3,25 @@
#include "buffer_hub.h"
-// #include <pdx/channel_handle.h>
-// #include <pdx/file_handle.h>
-// #include <pdx/rpc/buffer_wrapper.h>
-// #include <private/dvr/ion_buffer.h>
+#include <pdx/channel_handle.h>
+#include <pdx/file_handle.h>
namespace android {
namespace dvr {
class DetachedBufferChannel : public BufferHubChannel {
public:
- // Creates a detached buffer.
- DetachedBufferChannel(BufferHubService* service, int buffer_id,
- int channel_id, IonBuffer buffer,
- IonBuffer metadata_buffer, size_t user_metadata_size);
+ template <typename... Args>
+ static std::unique_ptr<DetachedBufferChannel> Create(Args&&... args) {
+ auto buffer = std::unique_ptr<DetachedBufferChannel>(
+ new DetachedBufferChannel(std::forward<Args>(args)...));
+ return buffer->IsValid() ? std::move(buffer) : nullptr;
+ }
+
+ // Returns whether the object holds a valid graphic buffer.
+ bool IsValid() const {
+ return buffer_.IsValid() && metadata_buffer_.IsValid();
+ }
size_t user_metadata_size() const { return user_metadata_size_; }
@@ -27,6 +32,19 @@
void HandleImpulse(pdx::Message& message) override;
private:
+ // Creates a detached buffer from existing IonBuffers.
+ DetachedBufferChannel(BufferHubService* service, int buffer_id,
+ int channel_id, IonBuffer buffer,
+ IonBuffer metadata_buffer, size_t user_metadata_size);
+
+ // Allocates a new detached buffer.
+ DetachedBufferChannel(BufferHubService* service, int buffer_id,
+ uint32_t width, uint32_t height, uint32_t layer_count,
+ uint32_t format, uint64_t usage,
+ size_t user_metadata_size);
+
+ pdx::Status<BufferDescription<pdx::BorrowedHandle>> OnImport(
+ pdx::Message& message);
pdx::Status<pdx::RemoteChannelHandle> OnPromote(pdx::Message& message);
// Gralloc buffer handles.
diff --git a/services/vr/bufferhubd/producer_channel.cpp b/services/vr/bufferhubd/producer_channel.cpp
index c38c12b..a753168 100644
--- a/services/vr/bufferhubd/producer_channel.cpp
+++ b/services/vr/bufferhubd/producer_channel.cpp
@@ -377,11 +377,17 @@
return ErrorStatus(-ret);
};
- auto channel = std::make_shared<DetachedBufferChannel>(
- service(), buffer_id(), channel_id, std::move(buffer_),
- std::move(metadata_buffer_), user_metadata_size_);
+ std::unique_ptr<DetachedBufferChannel> channel =
+ DetachedBufferChannel::Create(
+ service(), buffer_id(), channel_id, std::move(buffer_),
+ std::move(metadata_buffer_), user_metadata_size_);
+ if (!channel) {
+ ALOGE("ProducerChannel::OnProducerDetach: Invalid buffer.");
+ return ErrorStatus(EINVAL);
+ }
- const auto channel_status = service()->SetChannel(channel_id, channel);
+ const auto channel_status =
+ service()->SetChannel(channel_id, std::move(channel));
if (!channel_status) {
// Technically, this should never fail, as we just pushed the channel. Note
// that LOG_FATAL will be stripped out in non-debug build.
diff --git a/vulkan/Android.bp b/vulkan/Android.bp
index a49b6dd..b15bed9 100644
--- a/vulkan/Android.bp
+++ b/vulkan/Android.bp
@@ -55,4 +55,5 @@
"nulldrv",
"libvulkan",
"tools",
+ "vkjson",
]
diff --git a/vulkan/vkjson/.clang-format b/vulkan/vkjson/.clang-format
new file mode 100644
index 0000000..3f19e61
--- /dev/null
+++ b/vulkan/vkjson/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Chromium
diff --git a/vulkan/vkjson/Android.bp b/vulkan/vkjson/Android.bp
new file mode 100644
index 0000000..e387165
--- /dev/null
+++ b/vulkan/vkjson/Android.bp
@@ -0,0 +1,52 @@
+cc_library_static {
+ name: "libvkjson",
+ srcs: [
+ "vkjson.cc",
+ "vkjson_instance.cc",
+ ],
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+ cppflags: [
+ "-std=c++11",
+ "-Wno-sign-compare",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+ whole_static_libs: [
+ "libjsoncpp",
+ ],
+ header_libs: [
+ "vulkan_headers",
+ ],
+}
+
+cc_library_static {
+ name: "libvkjson_ndk",
+ clang: true,
+ srcs: [
+ "vkjson.cc",
+ "vkjson_instance.cc",
+ ],
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+ cppflags: [
+ "-std=c++11",
+ "-Wno-sign-compare",
+ ],
+ export_include_dirs: [
+ ".",
+ ],
+ whole_static_libs: [
+ "libjsoncpp_ndk",
+ ],
+ header_libs: [
+ "vulkan_headers_ndk",
+ ],
+ sdk_version: "24",
+ stl: "libc++_static",
+}
diff --git a/vulkan/vkjson/vkjson.cc b/vulkan/vkjson/vkjson.cc
new file mode 100644
index 0000000..6200383
--- /dev/null
+++ b/vulkan/vkjson/vkjson.cc
@@ -0,0 +1,1125 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+// Copyright (c) 2015-2016 Valve Corporation
+// Copyright (c) 2015-2016 LunarG, Inc.
+// Copyright (c) 2015-2016 Google, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "vkjson.h"
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <cmath>
+#include <cinttypes>
+#include <cstdio>
+#include <limits>
+#include <memory>
+#include <sstream>
+#include <type_traits>
+#include <utility>
+
+#include <json/json.h>
+
+namespace {
+
+inline bool IsIntegral(double value) {
+#if defined(ANDROID)
+ // Android NDK doesn't provide std::trunc yet
+ return trunc(value) == value;
+#else
+ return std::trunc(value) == value;
+#endif
+}
+
+template <typename T> struct EnumTraits;
+template <> struct EnumTraits<VkPhysicalDeviceType> {
+ static uint32_t min() { return VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE; }
+ static uint32_t max() { return VK_PHYSICAL_DEVICE_TYPE_END_RANGE; }
+ static bool exist(uint32_t e) { return e >= min() && e <= max(); }
+};
+
+template <> struct EnumTraits<VkFormat> {
+ static bool exist(uint32_t e) {
+ switch (e) {
+ case VK_FORMAT_UNDEFINED:
+ case VK_FORMAT_R4G4_UNORM_PACK8:
+ case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
+ case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
+ case VK_FORMAT_R5G6B5_UNORM_PACK16:
+ case VK_FORMAT_B5G6R5_UNORM_PACK16:
+ case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
+ case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
+ case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
+ case VK_FORMAT_R8_UNORM:
+ case VK_FORMAT_R8_SNORM:
+ case VK_FORMAT_R8_USCALED:
+ case VK_FORMAT_R8_SSCALED:
+ case VK_FORMAT_R8_UINT:
+ case VK_FORMAT_R8_SINT:
+ case VK_FORMAT_R8_SRGB:
+ case VK_FORMAT_R8G8_UNORM:
+ case VK_FORMAT_R8G8_SNORM:
+ case VK_FORMAT_R8G8_USCALED:
+ case VK_FORMAT_R8G8_SSCALED:
+ case VK_FORMAT_R8G8_UINT:
+ case VK_FORMAT_R8G8_SINT:
+ case VK_FORMAT_R8G8_SRGB:
+ case VK_FORMAT_R8G8B8_UNORM:
+ case VK_FORMAT_R8G8B8_SNORM:
+ case VK_FORMAT_R8G8B8_USCALED:
+ case VK_FORMAT_R8G8B8_SSCALED:
+ case VK_FORMAT_R8G8B8_UINT:
+ case VK_FORMAT_R8G8B8_SINT:
+ case VK_FORMAT_R8G8B8_SRGB:
+ case VK_FORMAT_B8G8R8_UNORM:
+ case VK_FORMAT_B8G8R8_SNORM:
+ case VK_FORMAT_B8G8R8_USCALED:
+ case VK_FORMAT_B8G8R8_SSCALED:
+ case VK_FORMAT_B8G8R8_UINT:
+ case VK_FORMAT_B8G8R8_SINT:
+ case VK_FORMAT_B8G8R8_SRGB:
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ case VK_FORMAT_R8G8B8A8_SNORM:
+ case VK_FORMAT_R8G8B8A8_USCALED:
+ case VK_FORMAT_R8G8B8A8_SSCALED:
+ case VK_FORMAT_R8G8B8A8_UINT:
+ case VK_FORMAT_R8G8B8A8_SINT:
+ case VK_FORMAT_R8G8B8A8_SRGB:
+ case VK_FORMAT_B8G8R8A8_UNORM:
+ case VK_FORMAT_B8G8R8A8_SNORM:
+ case VK_FORMAT_B8G8R8A8_USCALED:
+ case VK_FORMAT_B8G8R8A8_SSCALED:
+ case VK_FORMAT_B8G8R8A8_UINT:
+ case VK_FORMAT_B8G8R8A8_SINT:
+ case VK_FORMAT_B8G8R8A8_SRGB:
+ case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
+ case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
+ case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
+ case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
+ case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+ case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+ case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+ case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+ case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
+ case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
+ case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
+ case VK_FORMAT_A2R10G10B10_UINT_PACK32:
+ case VK_FORMAT_A2R10G10B10_SINT_PACK32:
+ case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+ case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
+ case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
+ case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
+ case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+ case VK_FORMAT_A2B10G10R10_SINT_PACK32:
+ case VK_FORMAT_R16_UNORM:
+ case VK_FORMAT_R16_SNORM:
+ case VK_FORMAT_R16_USCALED:
+ case VK_FORMAT_R16_SSCALED:
+ case VK_FORMAT_R16_UINT:
+ case VK_FORMAT_R16_SINT:
+ case VK_FORMAT_R16_SFLOAT:
+ case VK_FORMAT_R16G16_UNORM:
+ case VK_FORMAT_R16G16_SNORM:
+ case VK_FORMAT_R16G16_USCALED:
+ case VK_FORMAT_R16G16_SSCALED:
+ case VK_FORMAT_R16G16_UINT:
+ case VK_FORMAT_R16G16_SINT:
+ case VK_FORMAT_R16G16_SFLOAT:
+ case VK_FORMAT_R16G16B16_UNORM:
+ case VK_FORMAT_R16G16B16_SNORM:
+ case VK_FORMAT_R16G16B16_USCALED:
+ case VK_FORMAT_R16G16B16_SSCALED:
+ case VK_FORMAT_R16G16B16_UINT:
+ case VK_FORMAT_R16G16B16_SINT:
+ case VK_FORMAT_R16G16B16_SFLOAT:
+ case VK_FORMAT_R16G16B16A16_UNORM:
+ case VK_FORMAT_R16G16B16A16_SNORM:
+ case VK_FORMAT_R16G16B16A16_USCALED:
+ case VK_FORMAT_R16G16B16A16_SSCALED:
+ case VK_FORMAT_R16G16B16A16_UINT:
+ case VK_FORMAT_R16G16B16A16_SINT:
+ case VK_FORMAT_R16G16B16A16_SFLOAT:
+ case VK_FORMAT_R32_UINT:
+ case VK_FORMAT_R32_SINT:
+ case VK_FORMAT_R32_SFLOAT:
+ case VK_FORMAT_R32G32_UINT:
+ case VK_FORMAT_R32G32_SINT:
+ case VK_FORMAT_R32G32_SFLOAT:
+ case VK_FORMAT_R32G32B32_UINT:
+ case VK_FORMAT_R32G32B32_SINT:
+ case VK_FORMAT_R32G32B32_SFLOAT:
+ case VK_FORMAT_R32G32B32A32_UINT:
+ case VK_FORMAT_R32G32B32A32_SINT:
+ case VK_FORMAT_R32G32B32A32_SFLOAT:
+ case VK_FORMAT_R64_UINT:
+ case VK_FORMAT_R64_SINT:
+ case VK_FORMAT_R64_SFLOAT:
+ case VK_FORMAT_R64G64_UINT:
+ case VK_FORMAT_R64G64_SINT:
+ case VK_FORMAT_R64G64_SFLOAT:
+ case VK_FORMAT_R64G64B64_UINT:
+ case VK_FORMAT_R64G64B64_SINT:
+ case VK_FORMAT_R64G64B64_SFLOAT:
+ case VK_FORMAT_R64G64B64A64_UINT:
+ case VK_FORMAT_R64G64B64A64_SINT:
+ case VK_FORMAT_R64G64B64A64_SFLOAT:
+ case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
+ case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+ case VK_FORMAT_D16_UNORM:
+ case VK_FORMAT_X8_D24_UNORM_PACK32:
+ case VK_FORMAT_D32_SFLOAT:
+ case VK_FORMAT_S8_UINT:
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
+ case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
+ case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
+ case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
+ case VK_FORMAT_BC2_UNORM_BLOCK:
+ case VK_FORMAT_BC2_SRGB_BLOCK:
+ case VK_FORMAT_BC3_UNORM_BLOCK:
+ case VK_FORMAT_BC3_SRGB_BLOCK:
+ case VK_FORMAT_BC4_UNORM_BLOCK:
+ case VK_FORMAT_BC4_SNORM_BLOCK:
+ case VK_FORMAT_BC5_UNORM_BLOCK:
+ case VK_FORMAT_BC5_SNORM_BLOCK:
+ case VK_FORMAT_BC6H_UFLOAT_BLOCK:
+ case VK_FORMAT_BC6H_SFLOAT_BLOCK:
+ case VK_FORMAT_BC7_UNORM_BLOCK:
+ case VK_FORMAT_BC7_SRGB_BLOCK:
+ case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
+ case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
+ case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
+ case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
+ case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
+ case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
+ case VK_FORMAT_EAC_R11_UNORM_BLOCK:
+ case VK_FORMAT_EAC_R11_SNORM_BLOCK:
+ case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
+ case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
+ case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
+ case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
+ case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
+ case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
+ case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
+ case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
+ case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
+ case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
+ case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
+ case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
+ case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
+ case VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
+ case VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case VK_FORMAT_R10X6_UNORM_PACK16_KHR:
+ case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
+ case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_R12X4_UNORM_PACK16_KHR:
+ case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
+ case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
+ case VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ return true;
+ }
+ return false;
+ }
+};
+
+template <>
+struct EnumTraits<VkPointClippingBehavior> {
+ static uint32_t min() { return VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE; }
+ static uint32_t max() { return VK_POINT_CLIPPING_BEHAVIOR_END_RANGE; }
+ static bool exist(uint32_t e) { return e >= min() && e <= max(); }
+};
+
+template <>
+struct EnumTraits<VkExternalFenceHandleTypeFlagBits> {
+ static bool exist(uint32_t e) {
+ switch (e) {
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
+ case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
+ return true;
+ }
+ return false;
+ }
+};
+
+template <>
+struct EnumTraits<VkExternalSemaphoreHandleTypeFlagBits> {
+ static bool exist(uint32_t e) {
+ switch (e) {
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
+ return true;
+ }
+ return false;
+ }
+};
+
+// VkSparseImageFormatProperties
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkExtent3D* extents) {
+ return
+ visitor->Visit("width", &extents->width) &&
+ visitor->Visit("height", &extents->height) &&
+ visitor->Visit("depth", &extents->depth);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkImageFormatProperties* properties) {
+ return
+ visitor->Visit("maxExtent", &properties->maxExtent) &&
+ visitor->Visit("maxMipLevels", &properties->maxMipLevels) &&
+ visitor->Visit("maxArrayLayers", &properties->maxArrayLayers) &&
+ visitor->Visit("sampleCounts", &properties->sampleCounts) &&
+ visitor->Visit("maxResourceSize", &properties->maxResourceSize);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkPhysicalDeviceLimits* limits) {
+ return
+ visitor->Visit("maxImageDimension1D", &limits->maxImageDimension1D) &&
+ visitor->Visit("maxImageDimension2D", &limits->maxImageDimension2D) &&
+ visitor->Visit("maxImageDimension3D", &limits->maxImageDimension3D) &&
+ visitor->Visit("maxImageDimensionCube", &limits->maxImageDimensionCube) &&
+ visitor->Visit("maxImageArrayLayers", &limits->maxImageArrayLayers) &&
+ visitor->Visit("maxTexelBufferElements", &limits->maxTexelBufferElements) &&
+ visitor->Visit("maxUniformBufferRange", &limits->maxUniformBufferRange) &&
+ visitor->Visit("maxStorageBufferRange", &limits->maxStorageBufferRange) &&
+ visitor->Visit("maxPushConstantsSize", &limits->maxPushConstantsSize) &&
+ visitor->Visit("maxMemoryAllocationCount", &limits->maxMemoryAllocationCount) &&
+ visitor->Visit("maxSamplerAllocationCount", &limits->maxSamplerAllocationCount) &&
+ visitor->Visit("bufferImageGranularity", &limits->bufferImageGranularity) &&
+ visitor->Visit("sparseAddressSpaceSize", &limits->sparseAddressSpaceSize) &&
+ visitor->Visit("maxBoundDescriptorSets", &limits->maxBoundDescriptorSets) &&
+ visitor->Visit("maxPerStageDescriptorSamplers", &limits->maxPerStageDescriptorSamplers) &&
+ visitor->Visit("maxPerStageDescriptorUniformBuffers", &limits->maxPerStageDescriptorUniformBuffers) &&
+ visitor->Visit("maxPerStageDescriptorStorageBuffers", &limits->maxPerStageDescriptorStorageBuffers) &&
+ visitor->Visit("maxPerStageDescriptorSampledImages", &limits->maxPerStageDescriptorSampledImages) &&
+ visitor->Visit("maxPerStageDescriptorStorageImages", &limits->maxPerStageDescriptorStorageImages) &&
+ visitor->Visit("maxPerStageDescriptorInputAttachments", &limits->maxPerStageDescriptorInputAttachments) &&
+ visitor->Visit("maxPerStageResources", &limits->maxPerStageResources) &&
+ visitor->Visit("maxDescriptorSetSamplers", &limits->maxDescriptorSetSamplers) &&
+ visitor->Visit("maxDescriptorSetUniformBuffers", &limits->maxDescriptorSetUniformBuffers) &&
+ visitor->Visit("maxDescriptorSetUniformBuffersDynamic", &limits->maxDescriptorSetUniformBuffersDynamic) &&
+ visitor->Visit("maxDescriptorSetStorageBuffers", &limits->maxDescriptorSetStorageBuffers) &&
+ visitor->Visit("maxDescriptorSetStorageBuffersDynamic", &limits->maxDescriptorSetStorageBuffersDynamic) &&
+ visitor->Visit("maxDescriptorSetSampledImages", &limits->maxDescriptorSetSampledImages) &&
+ visitor->Visit("maxDescriptorSetStorageImages", &limits->maxDescriptorSetStorageImages) &&
+ visitor->Visit("maxDescriptorSetInputAttachments", &limits->maxDescriptorSetInputAttachments) &&
+ visitor->Visit("maxVertexInputAttributes", &limits->maxVertexInputAttributes) &&
+ visitor->Visit("maxVertexInputBindings", &limits->maxVertexInputBindings) &&
+ visitor->Visit("maxVertexInputAttributeOffset", &limits->maxVertexInputAttributeOffset) &&
+ visitor->Visit("maxVertexInputBindingStride", &limits->maxVertexInputBindingStride) &&
+ visitor->Visit("maxVertexOutputComponents", &limits->maxVertexOutputComponents) &&
+ visitor->Visit("maxTessellationGenerationLevel", &limits->maxTessellationGenerationLevel) &&
+ visitor->Visit("maxTessellationPatchSize", &limits->maxTessellationPatchSize) &&
+ visitor->Visit("maxTessellationControlPerVertexInputComponents", &limits->maxTessellationControlPerVertexInputComponents) &&
+ visitor->Visit("maxTessellationControlPerVertexOutputComponents", &limits->maxTessellationControlPerVertexOutputComponents) &&
+ visitor->Visit("maxTessellationControlPerPatchOutputComponents", &limits->maxTessellationControlPerPatchOutputComponents) &&
+ visitor->Visit("maxTessellationControlTotalOutputComponents", &limits->maxTessellationControlTotalOutputComponents) &&
+ visitor->Visit("maxTessellationEvaluationInputComponents", &limits->maxTessellationEvaluationInputComponents) &&
+ visitor->Visit("maxTessellationEvaluationOutputComponents", &limits->maxTessellationEvaluationOutputComponents) &&
+ visitor->Visit("maxGeometryShaderInvocations", &limits->maxGeometryShaderInvocations) &&
+ visitor->Visit("maxGeometryInputComponents", &limits->maxGeometryInputComponents) &&
+ visitor->Visit("maxGeometryOutputComponents", &limits->maxGeometryOutputComponents) &&
+ visitor->Visit("maxGeometryOutputVertices", &limits->maxGeometryOutputVertices) &&
+ visitor->Visit("maxGeometryTotalOutputComponents", &limits->maxGeometryTotalOutputComponents) &&
+ visitor->Visit("maxFragmentInputComponents", &limits->maxFragmentInputComponents) &&
+ visitor->Visit("maxFragmentOutputAttachments", &limits->maxFragmentOutputAttachments) &&
+ visitor->Visit("maxFragmentDualSrcAttachments", &limits->maxFragmentDualSrcAttachments) &&
+ visitor->Visit("maxFragmentCombinedOutputResources", &limits->maxFragmentCombinedOutputResources) &&
+ visitor->Visit("maxComputeSharedMemorySize", &limits->maxComputeSharedMemorySize) &&
+ visitor->Visit("maxComputeWorkGroupCount", &limits->maxComputeWorkGroupCount) &&
+ visitor->Visit("maxComputeWorkGroupInvocations", &limits->maxComputeWorkGroupInvocations) &&
+ visitor->Visit("maxComputeWorkGroupSize", &limits->maxComputeWorkGroupSize) &&
+ visitor->Visit("subPixelPrecisionBits", &limits->subPixelPrecisionBits) &&
+ visitor->Visit("subTexelPrecisionBits", &limits->subTexelPrecisionBits) &&
+ visitor->Visit("mipmapPrecisionBits", &limits->mipmapPrecisionBits) &&
+ visitor->Visit("maxDrawIndexedIndexValue", &limits->maxDrawIndexedIndexValue) &&
+ visitor->Visit("maxDrawIndirectCount", &limits->maxDrawIndirectCount) &&
+ visitor->Visit("maxSamplerLodBias", &limits->maxSamplerLodBias) &&
+ visitor->Visit("maxSamplerAnisotropy", &limits->maxSamplerAnisotropy) &&
+ visitor->Visit("maxViewports", &limits->maxViewports) &&
+ visitor->Visit("maxViewportDimensions", &limits->maxViewportDimensions) &&
+ visitor->Visit("viewportBoundsRange", &limits->viewportBoundsRange) &&
+ visitor->Visit("viewportSubPixelBits", &limits->viewportSubPixelBits) &&
+ visitor->Visit("minMemoryMapAlignment", &limits->minMemoryMapAlignment) &&
+ visitor->Visit("minTexelBufferOffsetAlignment", &limits->minTexelBufferOffsetAlignment) &&
+ visitor->Visit("minUniformBufferOffsetAlignment", &limits->minUniformBufferOffsetAlignment) &&
+ visitor->Visit("minStorageBufferOffsetAlignment", &limits->minStorageBufferOffsetAlignment) &&
+ visitor->Visit("minTexelOffset", &limits->minTexelOffset) &&
+ visitor->Visit("maxTexelOffset", &limits->maxTexelOffset) &&
+ visitor->Visit("minTexelGatherOffset", &limits->minTexelGatherOffset) &&
+ visitor->Visit("maxTexelGatherOffset", &limits->maxTexelGatherOffset) &&
+ visitor->Visit("minInterpolationOffset", &limits->minInterpolationOffset) &&
+ visitor->Visit("maxInterpolationOffset", &limits->maxInterpolationOffset) &&
+ visitor->Visit("subPixelInterpolationOffsetBits", &limits->subPixelInterpolationOffsetBits) &&
+ visitor->Visit("maxFramebufferWidth", &limits->maxFramebufferWidth) &&
+ visitor->Visit("maxFramebufferHeight", &limits->maxFramebufferHeight) &&
+ visitor->Visit("maxFramebufferLayers", &limits->maxFramebufferLayers) &&
+ visitor->Visit("framebufferColorSampleCounts", &limits->framebufferColorSampleCounts) &&
+ visitor->Visit("framebufferDepthSampleCounts", &limits->framebufferDepthSampleCounts) &&
+ visitor->Visit("framebufferStencilSampleCounts", &limits->framebufferStencilSampleCounts) &&
+ visitor->Visit("framebufferNoAttachmentsSampleCounts", &limits->framebufferNoAttachmentsSampleCounts) &&
+ visitor->Visit("maxColorAttachments", &limits->maxColorAttachments) &&
+ visitor->Visit("sampledImageColorSampleCounts", &limits->sampledImageColorSampleCounts) &&
+ visitor->Visit("sampledImageIntegerSampleCounts", &limits->sampledImageIntegerSampleCounts) &&
+ visitor->Visit("sampledImageDepthSampleCounts", &limits->sampledImageDepthSampleCounts) &&
+ visitor->Visit("sampledImageStencilSampleCounts", &limits->sampledImageStencilSampleCounts) &&
+ visitor->Visit("storageImageSampleCounts", &limits->storageImageSampleCounts) &&
+ visitor->Visit("maxSampleMaskWords", &limits->maxSampleMaskWords) &&
+ visitor->Visit("timestampComputeAndGraphics", &limits->timestampComputeAndGraphics) &&
+ visitor->Visit("timestampPeriod", &limits->timestampPeriod) &&
+ visitor->Visit("maxClipDistances", &limits->maxClipDistances) &&
+ visitor->Visit("maxCullDistances", &limits->maxCullDistances) &&
+ visitor->Visit("maxCombinedClipAndCullDistances", &limits->maxCombinedClipAndCullDistances) &&
+ visitor->Visit("discreteQueuePriorities", &limits->discreteQueuePriorities) &&
+ visitor->Visit("pointSizeRange", &limits->pointSizeRange) &&
+ visitor->Visit("lineWidthRange", &limits->lineWidthRange) &&
+ visitor->Visit("pointSizeGranularity", &limits->pointSizeGranularity) &&
+ visitor->Visit("lineWidthGranularity", &limits->lineWidthGranularity) &&
+ visitor->Visit("strictLines", &limits->strictLines) &&
+ visitor->Visit("standardSampleLocations", &limits->standardSampleLocations) &&
+ visitor->Visit("optimalBufferCopyOffsetAlignment", &limits->optimalBufferCopyOffsetAlignment) &&
+ visitor->Visit("optimalBufferCopyRowPitchAlignment", &limits->optimalBufferCopyRowPitchAlignment) &&
+ visitor->Visit("nonCoherentAtomSize", &limits->nonCoherentAtomSize);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceSparseProperties* properties) {
+ return
+ visitor->Visit("residencyStandard2DBlockShape", &properties->residencyStandard2DBlockShape) &&
+ visitor->Visit("residencyStandard2DMultisampleBlockShape", &properties->residencyStandard2DMultisampleBlockShape) &&
+ visitor->Visit("residencyStandard3DBlockShape", &properties->residencyStandard3DBlockShape) &&
+ visitor->Visit("residencyAlignedMipSize", &properties->residencyAlignedMipSize) &&
+ visitor->Visit("residencyNonResidentStrict", &properties->residencyNonResidentStrict);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceProperties* properties) {
+ return
+ visitor->Visit("apiVersion", &properties->apiVersion) &&
+ visitor->Visit("driverVersion", &properties->driverVersion) &&
+ visitor->Visit("vendorID", &properties->vendorID) &&
+ visitor->Visit("deviceID", &properties->deviceID) &&
+ visitor->Visit("deviceType", &properties->deviceType) &&
+ visitor->Visit("deviceName", &properties->deviceName) &&
+ visitor->Visit("pipelineCacheUUID", &properties->pipelineCacheUUID) &&
+ visitor->Visit("limits", &properties->limits) &&
+ visitor->Visit("sparseProperties", &properties->sparseProperties);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkPhysicalDeviceFeatures* features) {
+ return
+ visitor->Visit("robustBufferAccess", &features->robustBufferAccess) &&
+ visitor->Visit("fullDrawIndexUint32", &features->fullDrawIndexUint32) &&
+ visitor->Visit("imageCubeArray", &features->imageCubeArray) &&
+ visitor->Visit("independentBlend", &features->independentBlend) &&
+ visitor->Visit("geometryShader", &features->geometryShader) &&
+ visitor->Visit("tessellationShader", &features->tessellationShader) &&
+ visitor->Visit("sampleRateShading", &features->sampleRateShading) &&
+ visitor->Visit("dualSrcBlend", &features->dualSrcBlend) &&
+ visitor->Visit("logicOp", &features->logicOp) &&
+ visitor->Visit("multiDrawIndirect", &features->multiDrawIndirect) &&
+ visitor->Visit("drawIndirectFirstInstance", &features->drawIndirectFirstInstance) &&
+ visitor->Visit("depthClamp", &features->depthClamp) &&
+ visitor->Visit("depthBiasClamp", &features->depthBiasClamp) &&
+ visitor->Visit("fillModeNonSolid", &features->fillModeNonSolid) &&
+ visitor->Visit("depthBounds", &features->depthBounds) &&
+ visitor->Visit("wideLines", &features->wideLines) &&
+ visitor->Visit("largePoints", &features->largePoints) &&
+ visitor->Visit("alphaToOne", &features->alphaToOne) &&
+ visitor->Visit("multiViewport", &features->multiViewport) &&
+ visitor->Visit("samplerAnisotropy", &features->samplerAnisotropy) &&
+ visitor->Visit("textureCompressionETC2", &features->textureCompressionETC2) &&
+ visitor->Visit("textureCompressionASTC_LDR", &features->textureCompressionASTC_LDR) &&
+ visitor->Visit("textureCompressionBC", &features->textureCompressionBC) &&
+ visitor->Visit("occlusionQueryPrecise", &features->occlusionQueryPrecise) &&
+ visitor->Visit("pipelineStatisticsQuery", &features->pipelineStatisticsQuery) &&
+ visitor->Visit("vertexPipelineStoresAndAtomics", &features->vertexPipelineStoresAndAtomics) &&
+ visitor->Visit("fragmentStoresAndAtomics", &features->fragmentStoresAndAtomics) &&
+ visitor->Visit("shaderTessellationAndGeometryPointSize", &features->shaderTessellationAndGeometryPointSize) &&
+ visitor->Visit("shaderImageGatherExtended", &features->shaderImageGatherExtended) &&
+ visitor->Visit("shaderStorageImageExtendedFormats", &features->shaderStorageImageExtendedFormats) &&
+ visitor->Visit("shaderStorageImageMultisample", &features->shaderStorageImageMultisample) &&
+ visitor->Visit("shaderStorageImageReadWithoutFormat", &features->shaderStorageImageReadWithoutFormat) &&
+ visitor->Visit("shaderStorageImageWriteWithoutFormat", &features->shaderStorageImageWriteWithoutFormat) &&
+ visitor->Visit("shaderUniformBufferArrayDynamicIndexing", &features->shaderUniformBufferArrayDynamicIndexing) &&
+ visitor->Visit("shaderSampledImageArrayDynamicIndexing", &features->shaderSampledImageArrayDynamicIndexing) &&
+ visitor->Visit("shaderStorageBufferArrayDynamicIndexing", &features->shaderStorageBufferArrayDynamicIndexing) &&
+ visitor->Visit("shaderStorageImageArrayDynamicIndexing", &features->shaderStorageImageArrayDynamicIndexing) &&
+ visitor->Visit("shaderClipDistance", &features->shaderClipDistance) &&
+ visitor->Visit("shaderCullDistance", &features->shaderCullDistance) &&
+ visitor->Visit("shaderFloat64", &features->shaderFloat64) &&
+ visitor->Visit("shaderInt64", &features->shaderInt64) &&
+ visitor->Visit("shaderInt16", &features->shaderInt16) &&
+ visitor->Visit("shaderResourceResidency", &features->shaderResourceResidency) &&
+ visitor->Visit("shaderResourceMinLod", &features->shaderResourceMinLod) &&
+ visitor->Visit("sparseBinding", &features->sparseBinding) &&
+ visitor->Visit("sparseResidencyBuffer", &features->sparseResidencyBuffer) &&
+ visitor->Visit("sparseResidencyImage2D", &features->sparseResidencyImage2D) &&
+ visitor->Visit("sparseResidencyImage3D", &features->sparseResidencyImage3D) &&
+ visitor->Visit("sparseResidency2Samples", &features->sparseResidency2Samples) &&
+ visitor->Visit("sparseResidency4Samples", &features->sparseResidency4Samples) &&
+ visitor->Visit("sparseResidency8Samples", &features->sparseResidency8Samples) &&
+ visitor->Visit("sparseResidency16Samples", &features->sparseResidency16Samples) &&
+ visitor->Visit("sparseResidencyAliased", &features->sparseResidencyAliased) &&
+ visitor->Visit("variableMultisampleRate", &features->variableMultisampleRate) &&
+ visitor->Visit("inheritedQueries", &features->inheritedQueries);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkJsonExtVariablePointerFeatures* features) {
+ return visitor->Visit("variablePointerFeaturesKHR",
+ &features->variable_pointer_features_khr);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkMemoryType* type) {
+ return
+ visitor->Visit("propertyFlags", &type->propertyFlags) &&
+ visitor->Visit("heapIndex", &type->heapIndex);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkMemoryHeap* heap) {
+ return
+ visitor->Visit("size", &heap->size) &&
+ visitor->Visit("flags", &heap->flags);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkPhysicalDeviceMemoryProperties* properties) {
+ return
+ visitor->Visit("memoryTypeCount", &properties->memoryTypeCount) &&
+ visitor->VisitArray("memoryTypes", properties->memoryTypeCount, &properties->memoryTypes) &&
+ visitor->Visit("memoryHeapCount", &properties->memoryHeapCount) &&
+ visitor->VisitArray("memoryHeaps", properties->memoryHeapCount, &properties->memoryHeaps);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceSubgroupProperties* properties) {
+ return visitor->Visit("subgroupSize", &properties->subgroupSize) &&
+ visitor->Visit("supportedStages", &properties->supportedStages) &&
+ visitor->Visit("supportedOperations",
+ &properties->supportedOperations) &&
+ visitor->Visit("quadOperationsInAllStages",
+ &properties->quadOperationsInAllStages);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDevicePointClippingProperties* properties) {
+ return visitor->Visit("pointClippingBehavior",
+ &properties->pointClippingBehavior);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceMultiviewProperties* properties) {
+ return visitor->Visit("maxMultiviewViewCount",
+ &properties->maxMultiviewViewCount) &&
+ visitor->Visit("maxMultiviewInstanceIndex",
+ &properties->maxMultiviewInstanceIndex);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceIDProperties* properties) {
+ return visitor->Visit("deviceUUID", &properties->deviceUUID) &&
+ visitor->Visit("driverUUID", &properties->driverUUID) &&
+ visitor->Visit("deviceLUID", &properties->deviceLUID) &&
+ visitor->Visit("deviceNodeMask", &properties->deviceNodeMask) &&
+ visitor->Visit("deviceLUIDValid", &properties->deviceLUIDValid);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceMaintenance3Properties* properties) {
+ return visitor->Visit("maxPerSetDescriptors",
+ &properties->maxPerSetDescriptors) &&
+ visitor->Visit("maxMemoryAllocationSize",
+ &properties->maxMemoryAllocationSize);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDevice16BitStorageFeatures* features) {
+ return visitor->Visit("storageBuffer16BitAccess",
+ &features->storageBuffer16BitAccess) &&
+ visitor->Visit("uniformAndStorageBuffer16BitAccess",
+ &features->uniformAndStorageBuffer16BitAccess) &&
+ visitor->Visit("storagePushConstant16",
+ &features->storagePushConstant16) &&
+ visitor->Visit("storageInputOutput16",
+ &features->storageInputOutput16);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceMultiviewFeatures* features) {
+ return visitor->Visit("multiview", &features->multiview) &&
+ visitor->Visit("multiviewGeometryShader",
+ &features->multiviewGeometryShader) &&
+ visitor->Visit("multiviewTessellationShader",
+ &features->multiviewTessellationShader);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceVariablePointerFeatures* features) {
+ return visitor->Visit("variablePointersStorageBuffer",
+ &features->variablePointersStorageBuffer) &&
+ visitor->Visit("variablePointers", &features->variablePointers);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceProtectedMemoryFeatures* features) {
+ return visitor->Visit("protectedMemory", &features->protectedMemory);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* features) {
+ return visitor->Visit("samplerYcbcrConversion",
+ &features->samplerYcbcrConversion);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkPhysicalDeviceShaderDrawParameterFeatures* features) {
+ return visitor->Visit("shaderDrawParameters",
+ &features->shaderDrawParameters);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkExternalFenceProperties* properties) {
+ return visitor->Visit("exportFromImportedHandleTypes",
+ &properties->exportFromImportedHandleTypes) &&
+ visitor->Visit("compatibleHandleTypes",
+ &properties->compatibleHandleTypes) &&
+ visitor->Visit("externalFenceFeatures",
+ &properties->externalFenceFeatures);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor,
+ VkExternalSemaphoreProperties* properties) {
+ return visitor->Visit("exportFromImportedHandleTypes",
+ &properties->exportFromImportedHandleTypes) &&
+ visitor->Visit("compatibleHandleTypes",
+ &properties->compatibleHandleTypes) &&
+ visitor->Visit("externalSemaphoreFeatures",
+ &properties->externalSemaphoreFeatures);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkQueueFamilyProperties* properties) {
+ return
+ visitor->Visit("queueFlags", &properties->queueFlags) &&
+ visitor->Visit("queueCount", &properties->queueCount) &&
+ visitor->Visit("timestampValidBits", &properties->timestampValidBits) &&
+ visitor->Visit("minImageTransferGranularity", &properties->minImageTransferGranularity);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkExtensionProperties* properties) {
+ return
+ visitor->Visit("extensionName", &properties->extensionName) &&
+ visitor->Visit("specVersion", &properties->specVersion);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkLayerProperties* properties) {
+ return
+ visitor->Visit("layerName", &properties->layerName) &&
+ visitor->Visit("specVersion", &properties->specVersion) &&
+ visitor->Visit("implementationVersion", &properties->implementationVersion) &&
+ visitor->Visit("description", &properties->description);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkFormatProperties* properties) {
+ return
+ visitor->Visit("linearTilingFeatures", &properties->linearTilingFeatures) &&
+ visitor->Visit("optimalTilingFeatures", &properties->optimalTilingFeatures) &&
+ visitor->Visit("bufferFeatures", &properties->bufferFeatures);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkJsonLayer* layer) {
+ return visitor->Visit("properties", &layer->properties) &&
+ visitor->Visit("extensions", &layer->extensions);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkJsonDeviceGroup* device_group) {
+ return visitor->Visit("devices", &device_group->device_inds) &&
+ visitor->Visit("subsetAllocation",
+ &device_group->properties.subsetAllocation);
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkJsonDevice* device) {
+ bool ret = true;
+ switch (device->properties.apiVersion ^
+ VK_VERSION_PATCH(device->properties.apiVersion)) {
+ case VK_API_VERSION_1_1:
+ ret &=
+ visitor->Visit("subgroupProperties", &device->subgroup_properties) &&
+ visitor->Visit("pointClippingProperties",
+ &device->point_clipping_properties) &&
+ visitor->Visit("multiviewProperties",
+ &device->multiview_properties) &&
+ visitor->Visit("idProperties", &device->id_properties) &&
+ visitor->Visit("maintenance3Properties",
+ &device->maintenance3_properties) &&
+ visitor->Visit("16bitStorageFeatures",
+ &device->bit16_storage_features) &&
+ visitor->Visit("multiviewFeatures", &device->multiview_features) &&
+ visitor->Visit("variablePointerFeatures",
+ &device->variable_pointer_features) &&
+ visitor->Visit("protectedMemoryFeatures",
+ &device->protected_memory_features) &&
+ visitor->Visit("samplerYcbcrConversionFeatures",
+ &device->sampler_ycbcr_conversion_features) &&
+ visitor->Visit("shaderDrawParameterFeatures",
+ &device->shader_draw_parameter_features) &&
+ visitor->Visit("externalFenceProperties",
+ &device->external_fence_properties) &&
+ visitor->Visit("externalSemaphoreProperties",
+ &device->external_semaphore_properties);
+ case VK_API_VERSION_1_0:
+ ret &= visitor->Visit("properties", &device->properties) &&
+ visitor->Visit("features", &device->features) &&
+ visitor->Visit("VK_KHR_variable_pointers",
+ &device->ext_variable_pointer_features) &&
+ visitor->Visit("memory", &device->memory) &&
+ visitor->Visit("queues", &device->queues) &&
+ visitor->Visit("extensions", &device->extensions) &&
+ visitor->Visit("layers", &device->layers) &&
+ visitor->Visit("formats", &device->formats);
+ }
+ return ret;
+}
+
+template <typename Visitor>
+inline bool Iterate(Visitor* visitor, VkJsonInstance* instance) {
+ bool ret = true;
+ switch (instance->api_version ^ VK_VERSION_PATCH(instance->api_version)) {
+ case VK_API_VERSION_1_1:
+ ret &= visitor->Visit("deviceGroups", &instance->device_groups);
+ case VK_API_VERSION_1_0:
+ ret &= visitor->Visit("layers", &instance->layers) &&
+ visitor->Visit("extensions", &instance->extensions) &&
+ visitor->Visit("devices", &instance->devices);
+ }
+ return ret;
+}
+
+template <typename T>
+using EnableForArithmetic =
+ typename std::enable_if<std::is_arithmetic<T>::value, void>::type;
+
+template <typename T>
+using EnableForStruct =
+ typename std::enable_if<std::is_class<T>::value, void>::type;
+
+template <typename T>
+using EnableForEnum =
+ typename std::enable_if<std::is_enum<T>::value, void>::type;
+
+template <typename T, typename = EnableForStruct<T>, typename = void>
+Json::Value ToJsonValue(const T& value);
+
+template <typename T, typename = EnableForArithmetic<T>>
+inline Json::Value ToJsonValue(const T& value) {
+ return Json::Value(static_cast<double>(value));
+}
+
+inline Json::Value ToJsonValue(const uint64_t& value) {
+ char string[19] = {0}; // "0x" + 16 digits + terminal \0
+ snprintf(string, sizeof(string), "0x%016" PRIx64, value);
+ return Json::Value(string);
+}
+
+template <typename T, typename = EnableForEnum<T>, typename = void,
+ typename = void>
+inline Json::Value ToJsonValue(const T& value) {
+ return Json::Value(static_cast<double>(value));
+}
+
+template <typename T>
+inline Json::Value ArrayToJsonValue(uint32_t count, const T* values) {
+ Json::Value array(Json::arrayValue);
+ for (unsigned int i = 0; i < count; ++i) array.append(ToJsonValue(values[i]));
+ return array;
+}
+
+template <typename T, unsigned int N>
+inline Json::Value ToJsonValue(const T (&value)[N]) {
+ return ArrayToJsonValue(N, value);
+}
+
+template <size_t N>
+inline Json::Value ToJsonValue(const char (&value)[N]) {
+ assert(strlen(value) < N);
+ return Json::Value(value);
+}
+
+template <typename T>
+inline Json::Value ToJsonValue(const std::vector<T>& value) {
+ assert(value.size() <= std::numeric_limits<uint32_t>::max());
+ return ArrayToJsonValue(static_cast<uint32_t>(value.size()), value.data());
+}
+
+template <typename F, typename S>
+inline Json::Value ToJsonValue(const std::pair<F, S>& value) {
+ Json::Value array(Json::arrayValue);
+ array.append(ToJsonValue(value.first));
+ array.append(ToJsonValue(value.second));
+ return array;
+}
+
+template <typename F, typename S>
+inline Json::Value ToJsonValue(const std::map<F, S>& value) {
+ Json::Value array(Json::arrayValue);
+ for (auto& kv : value) array.append(ToJsonValue(kv));
+ return array;
+}
+
+class JsonWriterVisitor {
+ public:
+ JsonWriterVisitor() : object_(Json::objectValue) {}
+
+ ~JsonWriterVisitor() {}
+
+ template <typename T> bool Visit(const char* key, const T* value) {
+ object_[key] = ToJsonValue(*value);
+ return true;
+ }
+
+ template <typename T, uint32_t N>
+ bool VisitArray(const char* key, uint32_t count, const T (*value)[N]) {
+ assert(count <= N);
+ object_[key] = ArrayToJsonValue(count, *value);
+ return true;
+ }
+
+ Json::Value get_object() const { return object_; }
+
+ private:
+ Json::Value object_;
+};
+
+template <typename Visitor, typename T>
+inline void VisitForWrite(Visitor* visitor, const T& t) {
+ Iterate(visitor, const_cast<T*>(&t));
+}
+
+template <typename T, typename /*= EnableForStruct<T>*/, typename /*= void*/>
+Json::Value ToJsonValue(const T& value) {
+ JsonWriterVisitor visitor;
+ VisitForWrite(&visitor, value);
+ return visitor.get_object();
+}
+
+template <typename T, typename = EnableForStruct<T>>
+bool AsValue(Json::Value* json_value, T* t);
+
+inline bool AsValue(Json::Value* json_value, int32_t* value) {
+ if (json_value->type() != Json::realValue) return false;
+ double d = json_value->asDouble();
+ if (!IsIntegral(d) ||
+ d < static_cast<double>(std::numeric_limits<int32_t>::min()) ||
+ d > static_cast<double>(std::numeric_limits<int32_t>::max()))
+ return false;
+ *value = static_cast<int32_t>(d);
+ return true;
+}
+
+inline bool AsValue(Json::Value* json_value, uint64_t* value) {
+ if (json_value->type() != Json::stringValue) return false;
+ int result =
+ std::sscanf(json_value->asString().c_str(), "0x%016" PRIx64, value);
+ return result == 1;
+}
+
+inline bool AsValue(Json::Value* json_value, uint32_t* value) {
+ if (json_value->type() != Json::realValue) return false;
+ double d = json_value->asDouble();
+ if (!IsIntegral(d) || d < 0.0 ||
+ d > static_cast<double>(std::numeric_limits<uint32_t>::max()))
+ return false;
+ *value = static_cast<uint32_t>(d);
+ return true;
+}
+
+inline bool AsValue(Json::Value* json_value, uint8_t* value) {
+ uint32_t value32 = 0;
+ AsValue(json_value, &value32);
+ if (value32 > std::numeric_limits<uint8_t>::max())
+ return false;
+ *value = static_cast<uint8_t>(value32);
+ return true;
+}
+
+inline bool AsValue(Json::Value* json_value, float* value) {
+ if (json_value->type() != Json::realValue) return false;
+ *value = static_cast<float>(json_value->asDouble());
+ return true;
+}
+
+template <typename T>
+inline bool AsArray(Json::Value* json_value, uint32_t count, T* values) {
+ if (json_value->type() != Json::arrayValue || json_value->size() != count)
+ return false;
+ for (uint32_t i = 0; i < count; ++i) {
+ if (!AsValue(&(*json_value)[i], values + i)) return false;
+ }
+ return true;
+}
+
+template <typename T, unsigned int N>
+inline bool AsValue(Json::Value* json_value, T (*value)[N]) {
+ return AsArray(json_value, N, *value);
+}
+
+template <size_t N>
+inline bool AsValue(Json::Value* json_value, char (*value)[N]) {
+ if (json_value->type() != Json::stringValue) return false;
+ size_t len = json_value->asString().length();
+ if (len >= N)
+ return false;
+ memcpy(*value, json_value->asString().c_str(), len);
+ memset(*value + len, 0, N-len);
+ return true;
+}
+
+template <typename T, typename = EnableForEnum<T>, typename = void>
+inline bool AsValue(Json::Value* json_value, T* t) {
+ uint32_t value = 0;
+ if (!AsValue(json_value, &value))
+ return false;
+ if (!EnumTraits<T>::exist(value)) return false;
+ *t = static_cast<T>(value);
+ return true;
+}
+
+template <typename T>
+inline bool AsValue(Json::Value* json_value, std::vector<T>* value) {
+ if (json_value->type() != Json::arrayValue) return false;
+ int size = json_value->size();
+ value->resize(size);
+ return AsArray(json_value, size, value->data());
+}
+
+template <typename F, typename S>
+inline bool AsValue(Json::Value* json_value, std::pair<F, S>* value) {
+ if (json_value->type() != Json::arrayValue || json_value->size() != 2)
+ return false;
+ return AsValue(&(*json_value)[0], &value->first) &&
+ AsValue(&(*json_value)[1], &value->second);
+}
+
+template <typename F, typename S>
+inline bool AsValue(Json::Value* json_value, std::map<F, S>* value) {
+ if (json_value->type() != Json::arrayValue) return false;
+ int size = json_value->size();
+ for (int i = 0; i < size; ++i) {
+ std::pair<F, S> elem;
+ if (!AsValue(&(*json_value)[i], &elem)) return false;
+ if (!value->insert(elem).second)
+ return false;
+ }
+ return true;
+}
+
+template <typename T>
+bool ReadValue(Json::Value* object, const char* key, T* value,
+ std::string* errors) {
+ Json::Value json_value = (*object)[key];
+ if (!json_value) {
+ if (errors)
+ *errors = std::string(key) + " missing.";
+ return false;
+ }
+ if (AsValue(&json_value, value)) return true;
+ if (errors)
+ *errors = std::string("Wrong type for ") + std::string(key) + ".";
+ return false;
+}
+
+template <typename Visitor, typename T>
+inline bool VisitForRead(Visitor* visitor, T* t) {
+ return Iterate(visitor, t);
+}
+
+class JsonReaderVisitor {
+ public:
+ JsonReaderVisitor(Json::Value* object, std::string* errors)
+ : object_(object), errors_(errors) {}
+
+ template <typename T> bool Visit(const char* key, T* value) const {
+ return ReadValue(object_, key, value, errors_);
+ }
+
+ template <typename T, uint32_t N>
+ bool VisitArray(const char* key, uint32_t count, T (*value)[N]) {
+ if (count > N)
+ return false;
+ Json::Value json_value = (*object_)[key];
+ if (!json_value) {
+ if (errors_)
+ *errors_ = std::string(key) + " missing.";
+ return false;
+ }
+ if (AsArray(&json_value, count, *value)) return true;
+ if (errors_)
+ *errors_ = std::string("Wrong type for ") + std::string(key) + ".";
+ return false;
+ }
+
+
+ private:
+ Json::Value* object_;
+ std::string* errors_;
+};
+
+template <typename T, typename /*= EnableForStruct<T>*/>
+bool AsValue(Json::Value* json_value, T* t) {
+ if (json_value->type() != Json::objectValue) return false;
+ JsonReaderVisitor visitor(json_value, nullptr);
+ return VisitForRead(&visitor, t);
+}
+
+
+template <typename T> std::string VkTypeToJson(const T& t) {
+ JsonWriterVisitor visitor;
+ VisitForWrite(&visitor, t);
+ return visitor.get_object().toStyledString();
+}
+
+template <typename T> bool VkTypeFromJson(const std::string& json,
+ T* t,
+ std::string* errors) {
+ *t = T();
+ Json::Value object(Json::objectValue);
+ Json::Reader reader;
+ reader.parse(json, object, false);
+ if (!object) {
+ if (errors) errors->assign(reader.getFormatedErrorMessages());
+ return false;
+ }
+ return AsValue(&object, t);
+}
+
+} // anonymous namespace
+
+std::string VkJsonInstanceToJson(const VkJsonInstance& instance) {
+ return VkTypeToJson(instance);
+}
+
+bool VkJsonInstanceFromJson(const std::string& json,
+ VkJsonInstance* instance,
+ std::string* errors) {
+ return VkTypeFromJson(json, instance, errors);
+}
+
+std::string VkJsonDeviceToJson(const VkJsonDevice& device) {
+ return VkTypeToJson(device);
+}
+
+bool VkJsonDeviceFromJson(const std::string& json,
+ VkJsonDevice* device,
+ std::string* errors) {
+ return VkTypeFromJson(json, device, errors);
+};
+
+std::string VkJsonImageFormatPropertiesToJson(
+ const VkImageFormatProperties& properties) {
+ return VkTypeToJson(properties);
+}
+
+bool VkJsonImageFormatPropertiesFromJson(const std::string& json,
+ VkImageFormatProperties* properties,
+ std::string* errors) {
+ return VkTypeFromJson(json, properties, errors);
+};
diff --git a/vulkan/vkjson/vkjson.h b/vulkan/vkjson/vkjson.h
new file mode 100644
index 0000000..5e8428a
--- /dev/null
+++ b/vulkan/vkjson/vkjson.h
@@ -0,0 +1,162 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+// Copyright (c) 2015-2016 Valve Corporation
+// Copyright (c) 2015-2016 LunarG, Inc.
+// Copyright (c) 2015-2016 Google, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef VKJSON_H_
+#define VKJSON_H_
+
+#include <vulkan/vulkan.h>
+#include <string.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#ifdef WIN32
+#undef min
+#undef max
+#endif
+
+#ifndef VK_API_VERSION_1_0
+#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)
+#endif
+
+#ifndef VK_API_VERSION_1_1
+#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)
+#endif
+
+struct VkJsonLayer {
+ VkLayerProperties properties;
+ std::vector<VkExtensionProperties> extensions;
+};
+
+struct VkJsonExtVariablePointerFeatures {
+ VkJsonExtVariablePointerFeatures() {
+ memset(&variable_pointer_features_khr, 0,
+ sizeof(VkPhysicalDeviceVariablePointerFeaturesKHR));
+ }
+ VkPhysicalDeviceVariablePointerFeaturesKHR variable_pointer_features_khr;
+};
+
+struct VkJsonDevice {
+ VkJsonDevice() {
+ memset(&properties, 0, sizeof(VkPhysicalDeviceProperties));
+ memset(&features, 0, sizeof(VkPhysicalDeviceFeatures));
+ memset(&memory, 0, sizeof(VkPhysicalDeviceMemoryProperties));
+ memset(&subgroup_properties, 0, sizeof(VkPhysicalDeviceSubgroupProperties));
+ memset(&point_clipping_properties, 0,
+ sizeof(VkPhysicalDevicePointClippingProperties));
+ memset(&multiview_properties, 0,
+ sizeof(VkPhysicalDeviceMultiviewProperties));
+ memset(&id_properties, 0, sizeof(VkPhysicalDeviceIDProperties));
+ memset(&maintenance3_properties, 0,
+ sizeof(VkPhysicalDeviceMaintenance3Properties));
+ memset(&bit16_storage_features, 0,
+ sizeof(VkPhysicalDevice16BitStorageFeatures));
+ memset(&multiview_features, 0, sizeof(VkPhysicalDeviceMultiviewFeatures));
+ memset(&variable_pointer_features, 0,
+ sizeof(VkPhysicalDeviceVariablePointerFeatures));
+ memset(&protected_memory_features, 0,
+ sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
+ memset(&sampler_ycbcr_conversion_features, 0,
+ sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
+ memset(&shader_draw_parameter_features, 0,
+ sizeof(VkPhysicalDeviceShaderDrawParameterFeatures));
+ }
+ VkPhysicalDeviceProperties properties;
+ VkPhysicalDeviceFeatures features;
+ VkJsonExtVariablePointerFeatures ext_variable_pointer_features;
+ VkPhysicalDeviceMemoryProperties memory;
+ std::vector<VkQueueFamilyProperties> queues;
+ std::vector<VkExtensionProperties> extensions;
+ std::vector<VkLayerProperties> layers;
+ std::map<VkFormat, VkFormatProperties> formats;
+ VkPhysicalDeviceSubgroupProperties subgroup_properties;
+ VkPhysicalDevicePointClippingProperties point_clipping_properties;
+ VkPhysicalDeviceMultiviewProperties multiview_properties;
+ VkPhysicalDeviceIDProperties id_properties;
+ VkPhysicalDeviceMaintenance3Properties maintenance3_properties;
+ VkPhysicalDevice16BitStorageFeatures bit16_storage_features;
+ VkPhysicalDeviceMultiviewFeatures multiview_features;
+ VkPhysicalDeviceVariablePointerFeatures variable_pointer_features;
+ VkPhysicalDeviceProtectedMemoryFeatures protected_memory_features;
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures
+ sampler_ycbcr_conversion_features;
+ VkPhysicalDeviceShaderDrawParameterFeatures shader_draw_parameter_features;
+ std::map<VkExternalFenceHandleTypeFlagBits, VkExternalFenceProperties>
+ external_fence_properties;
+ std::map<VkExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreProperties>
+ external_semaphore_properties;
+};
+
+struct VkJsonDeviceGroup {
+ VkJsonDeviceGroup() {
+ memset(&properties, 0, sizeof(VkPhysicalDeviceGroupProperties));
+ }
+ VkPhysicalDeviceGroupProperties properties;
+ std::vector<uint32_t> device_inds;
+};
+
+struct VkJsonInstance {
+ VkJsonInstance() : api_version(0) {}
+ uint32_t api_version;
+ std::vector<VkJsonLayer> layers;
+ std::vector<VkExtensionProperties> extensions;
+ std::vector<VkJsonDevice> devices;
+ std::vector<VkJsonDeviceGroup> device_groups;
+};
+
+VkJsonInstance VkJsonGetInstance();
+std::string VkJsonInstanceToJson(const VkJsonInstance& instance);
+bool VkJsonInstanceFromJson(const std::string& json,
+ VkJsonInstance* instance,
+ std::string* errors);
+
+VkJsonDevice VkJsonGetDevice(VkInstance instance,
+ VkPhysicalDevice device,
+ uint32_t instanceExtensionCount,
+ const char* const* instanceExtensions);
+std::string VkJsonDeviceToJson(const VkJsonDevice& device);
+bool VkJsonDeviceFromJson(const std::string& json,
+ VkJsonDevice* device,
+ std::string* errors);
+
+std::string VkJsonImageFormatPropertiesToJson(
+ const VkImageFormatProperties& properties);
+bool VkJsonImageFormatPropertiesFromJson(const std::string& json,
+ VkImageFormatProperties* properties,
+ std::string* errors);
+
+// Backward-compatibility aliases
+typedef VkJsonDevice VkJsonAllProperties;
+inline VkJsonAllProperties VkJsonGetAllProperties(
+ VkPhysicalDevice physicalDevice) {
+ return VkJsonGetDevice(VK_NULL_HANDLE, physicalDevice, 0, nullptr);
+}
+inline std::string VkJsonAllPropertiesToJson(
+ const VkJsonAllProperties& properties) {
+ return VkJsonDeviceToJson(properties);
+}
+inline bool VkJsonAllPropertiesFromJson(const std::string& json,
+ VkJsonAllProperties* properties,
+ std::string* errors) {
+ return VkJsonDeviceFromJson(json, properties, errors);
+}
+
+#endif // VKJSON_H_
diff --git a/vulkan/vkjson/vkjson_info.cc b/vulkan/vkjson/vkjson_info.cc
new file mode 100644
index 0000000..3c4b08b
--- /dev/null
+++ b/vulkan/vkjson/vkjson_info.cc
@@ -0,0 +1,184 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+// Copyright (c) 2015-2016 Valve Corporation
+// Copyright (c) 2015-2016 LunarG, Inc.
+// Copyright (c) 2015-2016 Google, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef VK_PROTOTYPES
+#define VK_PROTOTYPES
+#endif
+
+#include "vkjson.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <iostream>
+#include <vector>
+
+const uint32_t unsignedNegOne = (uint32_t)(-1);
+
+struct Options {
+ bool instance = false;
+ uint32_t device_index = unsignedNegOne;
+ std::string device_name;
+ std::string output_file;
+};
+
+bool ParseOptions(int argc, char* argv[], Options* options) {
+ for (int i = 1; i < argc; ++i) {
+ std::string arg(argv[i]);
+ if (arg == "--instance" || arg == "-i") {
+ options->instance = true;
+ } else if (arg == "--first" || arg == "-f") {
+ options->device_index = 0;
+ } else {
+ ++i;
+ if (i >= argc) {
+ std::cerr << "Missing parameter after: " << arg << std::endl;
+ return false;
+ }
+ std::string arg2(argv[i]);
+ if (arg == "--device-index" || arg == "-d") {
+ int result = sscanf(arg2.c_str(), "%u", &options->device_index);
+ if (result != 1) {
+ options->device_index = static_cast<uint32_t>(-1);
+ std::cerr << "Unable to parse index: " << arg2 << std::endl;
+ return false;
+ }
+ } else if (arg == "--device-name" || arg == "-n") {
+ options->device_name = arg2;
+ } else if (arg == "--output" || arg == "-o") {
+ options->output_file = arg2;
+ } else {
+ std::cerr << "Unknown argument: " << arg << std::endl;
+ return false;
+ }
+ }
+ }
+ if (options->instance && (options->device_index != unsignedNegOne ||
+ !options->device_name.empty())) {
+ std::cerr << "Specifying a specific device is incompatible with dumping "
+ "the whole instance." << std::endl;
+ return false;
+ }
+ if (options->device_index != unsignedNegOne && !options->device_name.empty()) {
+ std::cerr << "Must specify only one of device index and device name."
+ << std::endl;
+ return false;
+ }
+ if (options->instance && options->output_file.empty()) {
+ std::cerr << "Must specify an output file when dumping the whole instance."
+ << std::endl;
+ return false;
+ }
+ if (!options->output_file.empty() && !options->instance &&
+ options->device_index == unsignedNegOne && options->device_name.empty()) {
+ std::cerr << "Must specify instance, device index, or device name when "
+ "specifying "
+ "output file." << std::endl;
+ return false;
+ }
+ return true;
+}
+
+bool Dump(const VkJsonInstance& instance, const Options& options) {
+ const VkJsonDevice* out_device = nullptr;
+ if (options.device_index != unsignedNegOne) {
+ if (static_cast<uint32_t>(options.device_index) >=
+ instance.devices.size()) {
+ std::cerr << "Error: device " << options.device_index
+ << " requested but only " << instance.devices.size()
+ << " devices found." << std::endl;
+ return false;
+ }
+ out_device = &instance.devices[options.device_index];
+ } else if (!options.device_name.empty()) {
+ for (const auto& device : instance.devices) {
+ if (device.properties.deviceName == options.device_name) {
+ out_device = &device;
+ }
+ }
+ if (!out_device) {
+ std::cerr << "Error: device '" << options.device_name
+ << "' requested but not found." << std::endl;
+ return false;
+ }
+ }
+
+ std::string output_file;
+ if (options.output_file.empty()) {
+ assert(out_device);
+#if defined(ANDROID)
+ output_file.assign("/sdcard/Android/" + std::string(out_device->properties.deviceName));
+#else
+ output_file.assign(out_device->properties.deviceName);
+#endif
+ output_file.append(".json");
+ } else {
+ output_file = options.output_file;
+ }
+ FILE* file = nullptr;
+ if (output_file == "-") {
+ file = stdout;
+ } else {
+ file = fopen(output_file.c_str(), "w");
+ if (!file) {
+ std::cerr << "Unable to open file " << output_file << "." << std::endl;
+ return false;
+ }
+ }
+
+ std::string json = out_device ? VkJsonDeviceToJson(*out_device)
+ : VkJsonInstanceToJson(instance);
+ fwrite(json.data(), 1, json.size(), file);
+ fputc('\n', file);
+
+ if (output_file != "-") {
+ fclose(file);
+ std::cout << "Wrote file " << output_file;
+ if (out_device)
+ std::cout << " for device " << out_device->properties.deviceName;
+ std::cout << "." << std::endl;
+ }
+ return true;
+}
+
+int main(int argc, char* argv[]) {
+#if defined(ANDROID)
+ int vulkanSupport = InitVulkan();
+ if (vulkanSupport == 0)
+ return 1;
+#endif
+ Options options;
+ if (!ParseOptions(argc, argv, &options))
+ return 1;
+
+ VkJsonInstance instance = VkJsonGetInstance();
+ if (options.instance || options.device_index != unsignedNegOne ||
+ !options.device_name.empty()) {
+ Dump(instance, options);
+ } else {
+ for (uint32_t i = 0, n = static_cast<uint32_t>(instance.devices.size()); i < n; i++) {
+ options.device_index = i;
+ Dump(instance, options);
+ }
+ }
+
+ return 0;
+}
diff --git a/vulkan/vkjson/vkjson_instance.cc b/vulkan/vkjson/vkjson_instance.cc
new file mode 100644
index 0000000..db0450d
--- /dev/null
+++ b/vulkan/vkjson/vkjson_instance.cc
@@ -0,0 +1,417 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+// Copyright (c) 2015-2016 Valve Corporation
+// Copyright (c) 2015-2016 LunarG, Inc.
+// Copyright (c) 2015-2016 Google, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef VK_PROTOTYPES
+#define VK_PROTOTYPES
+#endif
+
+#include "vkjson.h"
+
+#include <algorithm>
+#include <utility>
+
+namespace {
+const char* kSupportedInstanceExtensions[] = {
+ "VK_KHR_get_physical_device_properties2"};
+
+bool EnumerateExtensions(const char* layer_name,
+ std::vector<VkExtensionProperties>* extensions) {
+ VkResult result;
+ uint32_t count = 0;
+ result = vkEnumerateInstanceExtensionProperties(layer_name, &count, nullptr);
+ if (result != VK_SUCCESS)
+ return false;
+ extensions->resize(count);
+ result = vkEnumerateInstanceExtensionProperties(layer_name, &count,
+ extensions->data());
+ if (result != VK_SUCCESS)
+ return false;
+ return true;
+}
+
+bool HasExtension(const char* extension_name,
+ uint32_t count,
+ const char* const* extensions) {
+ return std::find_if(extensions, extensions + count,
+ [extension_name](const char* extension) {
+ return strcmp(extension, extension_name) == 0;
+ }) != extensions + count;
+}
+
+bool HasExtension(const char* extension_name,
+ const std::vector<VkExtensionProperties>& extensions) {
+ return std::find_if(extensions.cbegin(), extensions.cend(),
+ [extension_name](const VkExtensionProperties& extension) {
+ return strcmp(extension.extensionName,
+ extension_name) == 0;
+ }) != extensions.cend();
+}
+} // anonymous namespace
+
+VkJsonDevice VkJsonGetDevice(VkInstance instance,
+ VkPhysicalDevice physical_device,
+ uint32_t instance_extension_count,
+ const char* const* instance_extensions) {
+ VkJsonDevice device;
+
+ PFN_vkGetPhysicalDeviceFeatures2KHR vkpGetPhysicalDeviceFeatures2KHR =
+ nullptr;
+ if (instance != VK_NULL_HANDLE &&
+ HasExtension("VK_KHR_get_physical_device_properties2",
+ instance_extension_count, instance_extensions)) {
+ vkpGetPhysicalDeviceFeatures2KHR =
+ reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2KHR>(
+ vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"));
+ }
+
+ uint32_t extension_count = 0;
+ vkEnumerateDeviceExtensionProperties(physical_device, nullptr,
+ &extension_count, nullptr);
+ if (extension_count > 0) {
+ device.extensions.resize(extension_count);
+ vkEnumerateDeviceExtensionProperties(
+ physical_device, nullptr, &extension_count, device.extensions.data());
+ }
+
+ uint32_t layer_count = 0;
+ vkEnumerateDeviceLayerProperties(physical_device, &layer_count, nullptr);
+ if (layer_count > 0) {
+ device.layers.resize(layer_count);
+ vkEnumerateDeviceLayerProperties(physical_device, &layer_count,
+ device.layers.data());
+ }
+
+ vkGetPhysicalDeviceProperties(physical_device, &device.properties);
+ if (HasExtension("VK_KHR_get_physical_device_properties2",
+ instance_extension_count, instance_extensions)) {
+ VkPhysicalDeviceFeatures2KHR features = {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
+ nullptr,
+ {} // features
+ };
+ if (HasExtension("VK_KHR_variable_pointers", device.extensions)) {
+ device.ext_variable_pointer_features.variable_pointer_features_khr.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR;
+ device.ext_variable_pointer_features.variable_pointer_features_khr.pNext =
+ features.pNext;
+ features.pNext =
+ &device.ext_variable_pointer_features.variable_pointer_features_khr;
+ }
+ vkpGetPhysicalDeviceFeatures2KHR(physical_device, &features);
+ device.features = features.features;
+ } else {
+ vkGetPhysicalDeviceFeatures(physical_device, &device.features);
+ }
+ vkGetPhysicalDeviceMemoryProperties(physical_device, &device.memory);
+
+ uint32_t queue_family_count = 0;
+ vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count,
+ nullptr);
+ if (queue_family_count > 0) {
+ device.queues.resize(queue_family_count);
+ vkGetPhysicalDeviceQueueFamilyProperties(
+ physical_device, &queue_family_count, device.queues.data());
+ }
+
+ VkFormatProperties format_properties = {};
+ for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8;
+ format <= VK_FORMAT_END_RANGE;
+ format = static_cast<VkFormat>(format + 1)) {
+ vkGetPhysicalDeviceFormatProperties(physical_device, format,
+ &format_properties);
+ if (format_properties.linearTilingFeatures ||
+ format_properties.optimalTilingFeatures ||
+ format_properties.bufferFeatures) {
+ device.formats.insert(std::make_pair(format, format_properties));
+ }
+ }
+
+ if (device.properties.apiVersion >= VK_API_VERSION_1_1) {
+ for (VkFormat format = VK_FORMAT_G8B8G8R8_422_UNORM;
+ format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;
+ format = static_cast<VkFormat>(format + 1)) {
+ vkGetPhysicalDeviceFormatProperties(physical_device, format,
+ &format_properties);
+ if (format_properties.linearTilingFeatures ||
+ format_properties.optimalTilingFeatures ||
+ format_properties.bufferFeatures) {
+ device.formats.insert(std::make_pair(format, format_properties));
+ }
+ }
+
+ PFN_vkGetPhysicalDeviceProperties2 vkpGetPhysicalDeviceProperties2 =
+ reinterpret_cast<PFN_vkGetPhysicalDeviceProperties2>(
+ vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"));
+ if (vkpGetPhysicalDeviceProperties2) {
+ VkPhysicalDeviceProperties2 properties2 = {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, nullptr, {}};
+
+ device.subgroup_properties.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+ device.subgroup_properties.pNext = properties2.pNext;
+ properties2.pNext = &device.subgroup_properties;
+
+ device.point_clipping_properties.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+ device.point_clipping_properties.pNext = properties2.pNext;
+ properties2.pNext = &device.point_clipping_properties;
+
+ device.multiview_properties.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+ device.multiview_properties.pNext = properties2.pNext;
+ properties2.pNext = &device.multiview_properties;
+
+ device.id_properties.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
+ device.id_properties.pNext = properties2.pNext;
+ properties2.pNext = &device.id_properties;
+
+ device.maintenance3_properties.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+ device.maintenance3_properties.pNext = properties2.pNext;
+ properties2.pNext = &device.maintenance3_properties;
+
+ (*vkpGetPhysicalDeviceProperties2)(physical_device, &properties2);
+ }
+
+ PFN_vkGetPhysicalDeviceFeatures2 vkpGetPhysicalDeviceFeatures2 =
+ reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2>(
+ vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"));
+ if (vkpGetPhysicalDeviceFeatures2) {
+ VkPhysicalDeviceFeatures2 features2 = {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, nullptr, {}};
+
+ device.bit16_storage_features.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+ device.bit16_storage_features.pNext = features2.pNext;
+ features2.pNext = &device.bit16_storage_features;
+
+ device.multiview_features.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+ device.multiview_features.pNext = features2.pNext;
+ features2.pNext = &device.multiview_features;
+
+ device.variable_pointer_features.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES;
+ device.variable_pointer_features.pNext = features2.pNext;
+ features2.pNext = &device.variable_pointer_features;
+
+ device.protected_memory_features.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+ device.protected_memory_features.pNext = features2.pNext;
+ features2.pNext = &device.protected_memory_features;
+
+ device.sampler_ycbcr_conversion_features.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+ device.sampler_ycbcr_conversion_features.pNext = features2.pNext;
+ features2.pNext = &device.sampler_ycbcr_conversion_features;
+
+ device.shader_draw_parameter_features.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES;
+ device.shader_draw_parameter_features.pNext = features2.pNext;
+ features2.pNext = &device.shader_draw_parameter_features;
+
+ (*vkpGetPhysicalDeviceFeatures2)(physical_device, &features2);
+ }
+
+ PFN_vkGetPhysicalDeviceExternalFenceProperties
+ vkpGetPhysicalDeviceExternalFenceProperties =
+ reinterpret_cast<PFN_vkGetPhysicalDeviceExternalFenceProperties>(
+ vkGetInstanceProcAddr(
+ instance, "vkGetPhysicalDeviceExternalFenceProperties"));
+ if (vkpGetPhysicalDeviceExternalFenceProperties) {
+ VkPhysicalDeviceExternalFenceInfo external_fence_info = {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, nullptr,
+ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT};
+ VkExternalFenceProperties external_fence_properties = {};
+
+ for (VkExternalFenceHandleTypeFlagBits handle_type =
+ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT;
+ handle_type <= VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
+ handle_type = static_cast<VkExternalFenceHandleTypeFlagBits>(
+ handle_type << 1)) {
+ external_fence_info.handleType = handle_type;
+ (*vkpGetPhysicalDeviceExternalFenceProperties)(
+ physical_device, &external_fence_info, &external_fence_properties);
+ if (external_fence_properties.exportFromImportedHandleTypes ||
+ external_fence_properties.compatibleHandleTypes ||
+ external_fence_properties.externalFenceFeatures) {
+ device.external_fence_properties.insert(
+ std::make_pair(handle_type, external_fence_properties));
+ }
+ }
+ }
+
+ PFN_vkGetPhysicalDeviceExternalSemaphoreProperties
+ vkpGetPhysicalDeviceExternalSemaphoreProperties = reinterpret_cast<
+ PFN_vkGetPhysicalDeviceExternalSemaphoreProperties>(
+ vkGetInstanceProcAddr(
+ instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"));
+ if (vkpGetPhysicalDeviceExternalSemaphoreProperties) {
+ VkPhysicalDeviceExternalSemaphoreInfo external_semaphore_info = {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, nullptr,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT};
+ VkExternalSemaphoreProperties external_semaphore_properties = {};
+
+ for (VkExternalSemaphoreHandleTypeFlagBits handle_type =
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
+ handle_type <= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
+ handle_type = static_cast<VkExternalSemaphoreHandleTypeFlagBits>(
+ handle_type << 1)) {
+ external_semaphore_info.handleType = handle_type;
+ (*vkpGetPhysicalDeviceExternalSemaphoreProperties)(
+ physical_device, &external_semaphore_info,
+ &external_semaphore_properties);
+ if (external_semaphore_properties.exportFromImportedHandleTypes ||
+ external_semaphore_properties.compatibleHandleTypes ||
+ external_semaphore_properties.externalSemaphoreFeatures) {
+ device.external_semaphore_properties.insert(
+ std::make_pair(handle_type, external_semaphore_properties));
+ }
+ }
+ }
+ }
+
+ return device;
+}
+
+VkJsonInstance VkJsonGetInstance() {
+ VkJsonInstance instance;
+ VkResult result;
+ uint32_t count;
+
+ count = 0;
+ result = vkEnumerateInstanceLayerProperties(&count, nullptr);
+ if (result != VK_SUCCESS)
+ return VkJsonInstance();
+ if (count > 0) {
+ std::vector<VkLayerProperties> layers(count);
+ result = vkEnumerateInstanceLayerProperties(&count, layers.data());
+ if (result != VK_SUCCESS)
+ return VkJsonInstance();
+ instance.layers.reserve(count);
+ for (auto& layer : layers) {
+ instance.layers.push_back(VkJsonLayer{layer, std::vector<VkExtensionProperties>()});
+ if (!EnumerateExtensions(layer.layerName,
+ &instance.layers.back().extensions))
+ return VkJsonInstance();
+ }
+ }
+
+ if (!EnumerateExtensions(nullptr, &instance.extensions))
+ return VkJsonInstance();
+
+ std::vector<const char*> instance_extensions;
+ for (const auto extension : kSupportedInstanceExtensions) {
+ if (HasExtension(extension, instance.extensions))
+ instance_extensions.push_back(extension);
+ }
+
+ const VkApplicationInfo app_info = {VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ nullptr,
+ "vkjson_info",
+ 1,
+ "",
+ 0,
+ VK_API_VERSION_1_0};
+ VkInstanceCreateInfo instance_info = {
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+ nullptr,
+ 0,
+ &app_info,
+ 0,
+ nullptr,
+ static_cast<uint32_t>(instance_extensions.size()),
+ instance_extensions.data()};
+ VkInstance vkinstance;
+ result = vkCreateInstance(&instance_info, nullptr, &vkinstance);
+ if (result != VK_SUCCESS)
+ return VkJsonInstance();
+
+ count = 0;
+ result = vkEnumeratePhysicalDevices(vkinstance, &count, nullptr);
+ if (result != VK_SUCCESS) {
+ vkDestroyInstance(vkinstance, nullptr);
+ return VkJsonInstance();
+ }
+
+ std::vector<VkPhysicalDevice> devices(count, VK_NULL_HANDLE);
+ result = vkEnumeratePhysicalDevices(vkinstance, &count, devices.data());
+ if (result != VK_SUCCESS) {
+ vkDestroyInstance(vkinstance, nullptr);
+ return VkJsonInstance();
+ }
+
+ std::map<VkPhysicalDevice, uint32_t> device_map;
+ const uint32_t sz = devices.size();
+ instance.devices.reserve(sz);
+ for (uint32_t i = 0; i < sz; ++i) {
+ device_map.insert(std::make_pair(devices[i], i));
+ instance.devices.emplace_back(VkJsonGetDevice(vkinstance, devices[i],
+ instance_extensions.size(),
+ instance_extensions.data()));
+ }
+
+ PFN_vkEnumerateInstanceVersion vkpEnumerateInstanceVersion =
+ reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
+ vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion"));
+ if (!vkpEnumerateInstanceVersion) {
+ instance.api_version = VK_API_VERSION_1_0;
+ } else {
+ result = (*vkpEnumerateInstanceVersion)(&instance.api_version);
+ if (result != VK_SUCCESS) {
+ vkDestroyInstance(vkinstance, nullptr);
+ return VkJsonInstance();
+ }
+ }
+
+ PFN_vkEnumeratePhysicalDeviceGroups vkpEnumeratePhysicalDeviceGroups =
+ reinterpret_cast<PFN_vkEnumeratePhysicalDeviceGroups>(
+ vkGetInstanceProcAddr(vkinstance, "vkEnumeratePhysicalDeviceGroups"));
+ if (vkpEnumeratePhysicalDeviceGroups) {
+ count = 0;
+ result = (*vkpEnumeratePhysicalDeviceGroups)(vkinstance, &count, nullptr);
+ if (result != VK_SUCCESS) {
+ vkDestroyInstance(vkinstance, nullptr);
+ return VkJsonInstance();
+ }
+
+ VkJsonDeviceGroup device_group;
+ std::vector<VkPhysicalDeviceGroupProperties> group_properties;
+ group_properties.resize(count);
+ result = (*vkpEnumeratePhysicalDeviceGroups)(vkinstance, &count,
+ group_properties.data());
+ if (result != VK_SUCCESS) {
+ vkDestroyInstance(vkinstance, nullptr);
+ return VkJsonInstance();
+ }
+ for (auto properties : group_properties) {
+ device_group.properties = properties;
+ for (uint32_t i = 0; i < properties.physicalDeviceCount; ++i) {
+ device_group.device_inds.push_back(
+ device_map[properties.physicalDevices[i]]);
+ }
+ instance.device_groups.push_back(device_group);
+ }
+ }
+
+ vkDestroyInstance(vkinstance, nullptr);
+ return instance;
+}
diff --git a/vulkan/vkjson/vkjson_unittest.cc b/vulkan/vkjson/vkjson_unittest.cc
new file mode 100644
index 0000000..de765cd
--- /dev/null
+++ b/vulkan/vkjson/vkjson_unittest.cc
@@ -0,0 +1,101 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+// Copyright (c) 2015-2016 Valve Corporation
+// Copyright (c) 2015-2016 LunarG, Inc.
+// Copyright (c) 2015-2016 Google, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+///////////////////////////////////////////////////////////////////////////////
+
+#include "vkjson.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <iostream>
+
+#define EXPECT(X) if (!(X)) \
+ ReportFailure(__FILE__, __LINE__, #X);
+
+#define ASSERT(X) if (!(X)) { \
+ ReportFailure(__FILE__, __LINE__, #X); \
+ return 2; \
+}
+
+int g_failures;
+
+void ReportFailure(const char* file, int line, const char* assertion) {
+ std::cout << file << ":" << line << ": \"" << assertion << "\" failed."
+ << std::endl;
+ ++g_failures;
+}
+
+int main(int argc, char* argv[]) {
+ std::string errors;
+ bool result = false;
+
+ VkJsonInstance instance;
+ instance.devices.resize(1);
+ VkJsonDevice& device = instance.devices[0];
+
+ const char name[] = "Test device";
+ memcpy(device.properties.deviceName, name, sizeof(name));
+ device.properties.limits.maxImageDimension1D = 3;
+ device.properties.limits.maxSamplerLodBias = 3.5f;
+ device.properties.limits.bufferImageGranularity = 0x1ffffffffull;
+ device.properties.limits.maxViewportDimensions[0] = 1;
+ device.properties.limits.maxViewportDimensions[1] = 2;
+ VkFormatProperties format_props = {
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
+ VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT};
+ device.formats.insert(std::make_pair(VK_FORMAT_R8_UNORM, format_props));
+ device.formats.insert(std::make_pair(VK_FORMAT_R8G8_UNORM, format_props));
+
+ std::string json = VkJsonInstanceToJson(instance);
+ std::cout << json << std::endl;
+
+ VkJsonInstance instance2;
+ result = VkJsonInstanceFromJson(json, &instance2, &errors);
+ EXPECT(result);
+ if (!result)
+ std::cout << "Error: " << errors << std::endl;
+ const VkJsonDevice& device2 = instance2.devices.at(0);
+
+ EXPECT(!memcmp(&device.properties, &device2.properties,
+ sizeof(device.properties)));
+ for (auto& kv : device.formats) {
+ auto it = device2.formats.find(kv.first);
+ EXPECT(it != device2.formats.end());
+ EXPECT(!memcmp(&kv.second, &it->second, sizeof(kv.second)));
+ }
+
+ VkImageFormatProperties props = {};
+ json = VkJsonImageFormatPropertiesToJson(props);
+ VkImageFormatProperties props2 = {};
+ result = VkJsonImageFormatPropertiesFromJson(json, &props2, &errors);
+ EXPECT(result);
+ if (!result)
+ std::cout << "Error: " << errors << std::endl;
+
+ EXPECT(!memcmp(&props, &props2, sizeof(props)));
+
+ if (g_failures) {
+ std::cout << g_failures << " failures." << std::endl;
+ return 1;
+ } else {
+ std::cout << "Success." << std::endl;
+ return 0;
+ }
+}