| /* |
| * Copyright 2015, 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. |
| * |
| * THIS FILE WAS GENERATED BY apic. DO NOT EDIT. |
| */ |
| |
| |
| #include "abort_exception.h" |
| #include "vulkan_imports.h" |
| #include "vulkan_types.h" |
| |
| #include "vulkan_spy.h" |
| |
| #include <gapic/log.h> |
| #include <gapic/coder/memory.h> |
| #include <gapic/coder/atom.h> |
| #include <gapic/coder/vulkan.h> |
| |
| #define __STDC_FORMAT_MACROS |
| #include <inttypes.h> |
| |
| #include <stdint.h> |
| |
| #include <memory> |
| #include <string> |
| |
| namespace gapii { |
| |
| VkBool32 VulkanSpy::vkGetPhysicalDeviceXcbPresentationSupportKHR(CallObserver* observer, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { |
| GAPID_DEBUG("vkGetPhysicalDeviceXcbPresentationSupportKHR(%zu, %" PRIu32 ", %p, %" PRIu32 ")", physicalDevice, queueFamilyIndex, connection, visual_id); |
| |
| if (PhysicalDevices.find(physicalDevice) == PhysicalDevices.end() || |
| mImports.mVkInstanceFunctions.find(PhysicalDevices[physicalDevice]->mInstance) == mImports.mVkInstanceFunctions.end() || |
| mImports.mVkInstanceFunctions[PhysicalDevices[physicalDevice]->mInstance].vkGetPhysicalDeviceXcbPresentationSupportKHR == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkGetPhysicalDeviceXcbPresentationSupportKHR"); |
| return 0; |
| } |
| |
| VkBool32 result = 0; |
| bool called = false; |
| auto call = [this, observer, &called, &result, physicalDevice, queueFamilyIndex, connection, visual_id] { |
| called = true; |
| observer->observeReads(); |
| result = mImports.mVkInstanceFunctions[PhysicalDevices[physicalDevice]->mInstance].vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| call(); |
| break; |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkGetPhysicalDeviceXcbPresentationSupportKHR coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(physicalDevice, *observer->getScratch()), queueFamilyIndex, toEncoder< gapic::coder::vulkan::Xcb_connection_t__P >(connection, *observer->getScratch()), toEncoder< uint32_t >(visual_id, *observer->getScratch()), toEncoder< uint32_t >(result, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| |
| return result; |
| } |
| |
| uint32_t VulkanSpy::vkCreateMirSurfaceKHR(CallObserver* observer, VkInstance instance, VkMirSurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { |
| GAPID_DEBUG("vkCreateMirSurfaceKHR(%zu, %p, %p, %p)", instance, pCreateInfo, pAllocator, pSurface); |
| |
| if (mImports.mVkInstanceFunctions.find(instance) == mImports.mVkInstanceFunctions.end() || |
| mImports.mVkInstanceFunctions[instance].vkCreateMirSurfaceKHR == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCreateMirSurfaceKHR"); |
| return 0; |
| } |
| |
| uint32_t result = 0; |
| bool called = false; |
| auto call = [this, observer, &called, &result, instance, pCreateInfo, pAllocator, pSurface] { |
| called = true; |
| observer->observeReads(); |
| result = mImports.mVkInstanceFunctions[instance].vkCreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| call(); |
| break; |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCreateMirSurfaceKHR coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(instance, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkMirSurfaceCreateInfoKHR__CP >(pCreateInfo, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkAllocationCallbacks__CP >(pAllocator, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkSurfaceKHR__P >(pSurface, *observer->getScratch()), result); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| |
| return result; |
| } |
| |
| uint32_t VulkanSpy::vkEnumeratePhysicalDevices(CallObserver* observer, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { |
| GAPID_DEBUG("vkEnumeratePhysicalDevices(%zu, %p, %p)", instance, pPhysicalDeviceCount, pPhysicalDevices); |
| |
| if (mImports.mVkInstanceFunctions.find(instance) == mImports.mVkInstanceFunctions.end() || |
| mImports.mVkInstanceFunctions[instance].vkEnumeratePhysicalDevices == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkEnumeratePhysicalDevices"); |
| return 0; |
| } |
| |
| uint32_t result = 0; |
| bool called = false; |
| auto call = [this, observer, &called, &result, instance, pPhysicalDeviceCount, pPhysicalDevices] { |
| called = true; |
| observer->observeReads(); |
| result = mImports.mVkInstanceFunctions[instance].vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| (void)observer->read(slice(pPhysicalDeviceCount, 0ULL, 1ULL), 0ULL); |
| call(); |
| if ((pPhysicalDevices) == (nullptr)) { |
| observer->write<uint32_t>(slice(pPhysicalDeviceCount, 0ULL, 1ULL), 0ULL, slice(pPhysicalDeviceCount, 0ULL, 1ULL)[0ULL]); |
| } else { |
| uint32_t l_count = (uint32_t)(slice(pPhysicalDeviceCount, 0ULL, 1ULL)[0ULL]); |
| Slice<VkPhysicalDevice> l_devices = slice(pPhysicalDevices, (uint64_t)(0UL), (uint64_t)(l_count)); |
| for (uint32_t l_i = 0UL; l_i < l_count; ++l_i) { |
| auto l_device = slice(pPhysicalDevices, (uint64_t)(0UL), (uint64_t)(l_count))[(uint64_t)(l_i)]; |
| this->PhysicalDevices[l_device] = std::shared_ptr<PhysicalDeviceObject>(new PhysicalDeviceObject(instance, VkPhysicalDeviceMemoryProperties(), 0)); |
| observer->write<VkPhysicalDevice>(l_devices, (uint64_t)(l_i), l_device); |
| } |
| observer->write<uint32_t>(slice(pPhysicalDeviceCount, 0ULL, 1ULL), 0ULL, l_count); |
| } |
| break; |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkEnumeratePhysicalDevices coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(instance, *observer->getScratch()), toEncoder< gapic::coder::vulkan::U32__P >(pPhysicalDeviceCount, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkPhysicalDevice__P >(pPhysicalDevices, *observer->getScratch()), result); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| |
| return result; |
| } |
| |
| void VulkanSpy::vkGetImageMemoryRequirements(CallObserver* observer, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { |
| GAPID_DEBUG("vkGetImageMemoryRequirements(%zu, %" PRIu64 ", %p)", device, image, pMemoryRequirements); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkGetImageMemoryRequirements == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkGetImageMemoryRequirements"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, device, image, pMemoryRequirements] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[device].vkGetImageMemoryRequirements(device, image, pMemoryRequirements); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| call(); |
| auto l_requirements = slice(pMemoryRequirements, 0ULL, 1ULL)[0ULL]; |
| observer->write<VkMemoryRequirements>(slice(pMemoryRequirements, 0ULL, 1ULL), 0ULL, l_requirements); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkGetImageMemoryRequirements coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), toEncoder< uint64_t >(image, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkMemoryRequirements__P >(pMemoryRequirements, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkGetImageSparseMemoryRequirements(CallObserver* observer, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { |
| GAPID_DEBUG("vkGetImageSparseMemoryRequirements(%zu, %" PRIu64 ", %p, %p)", device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkGetImageSparseMemoryRequirements == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkGetImageSparseMemoryRequirements"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[device].vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkGetImageSparseMemoryRequirements coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), toEncoder< uint64_t >(image, *observer->getScratch()), toEncoder< gapic::coder::vulkan::U32__P >(pSparseMemoryRequirementCount, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkSparseImageMemoryRequirements__P >(pSparseMemoryRequirements, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkGetPhysicalDeviceSparseImageFormatProperties(CallObserver* observer, VkPhysicalDevice physicalDevice, uint32_t format, uint32_t type, uint32_t samples, VkImageUsageFlags usage, uint32_t tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { |
| GAPID_DEBUG("vkGetPhysicalDeviceSparseImageFormatProperties(%zu, %u, %u, %u, %" PRIu32 ", %u, %p, %p)", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); |
| |
| if (PhysicalDevices.find(physicalDevice) == PhysicalDevices.end() || |
| mImports.mVkInstanceFunctions.find(PhysicalDevices[physicalDevice]->mInstance) == mImports.mVkInstanceFunctions.end() || |
| mImports.mVkInstanceFunctions[PhysicalDevices[physicalDevice]->mInstance].vkGetPhysicalDeviceSparseImageFormatProperties == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkGetPhysicalDeviceSparseImageFormatProperties"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkInstanceFunctions[PhysicalDevices[physicalDevice]->mInstance].vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| (void)observer->read(slice(pPropertyCount, 0ULL, 1ULL), 0ULL); |
| call(); |
| if ((pProperties) == (nullptr)) { |
| observer->write<uint32_t>(slice(pPropertyCount, 0ULL, 1ULL), 0ULL, slice(pPropertyCount, 0ULL, 1ULL)[0ULL]); |
| } else { |
| uint32_t l_count = (uint32_t)(slice(pPropertyCount, 0ULL, 1ULL)[0ULL]); |
| Slice<VkSparseImageFormatProperties> l_properties = slice(pProperties, (uint64_t)(0UL), (uint64_t)(l_count)); |
| for (uint32_t l_i = 0UL; l_i < l_count; ++l_i) { |
| observer->write<VkSparseImageFormatProperties>(l_properties, (uint64_t)(l_i), slice(pProperties, (uint64_t)(0UL), (uint64_t)(l_count))[(uint64_t)(l_i)]); |
| } |
| observer->write<uint32_t>(slice(pPropertyCount, 0ULL, 1ULL), 0ULL, l_count); |
| } |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkGetPhysicalDeviceSparseImageFormatProperties coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(physicalDevice, *observer->getScratch()), format, type, samples, toEncoder< uint32_t >(usage, *observer->getScratch()), tiling, toEncoder< gapic::coder::vulkan::U32__P >(pPropertyCount, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkSparseImageFormatProperties__P >(pProperties, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| uint32_t VulkanSpy::vkWaitForFences(CallObserver* observer, VkDevice device, uint32_t fenceCount, VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { |
| GAPID_DEBUG("vkWaitForFences(%zu, %" PRIu32 ", %p, %" PRIu32 ", %" PRIu64 ")", device, fenceCount, pFences, waitAll, timeout); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkWaitForFences == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkWaitForFences"); |
| return 0; |
| } |
| |
| uint32_t result = 0; |
| bool called = false; |
| auto call = [this, observer, &called, &result, device, fenceCount, pFences, waitAll, timeout] { |
| called = true; |
| observer->observeReads(); |
| result = mImports.mVkDeviceFunctions[device].vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| observer->read(slice(pFences, (uint64_t)(0UL), (uint64_t)(fenceCount))); |
| call(); |
| break; |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkWaitForFences coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), fenceCount, toEncoder< gapic::coder::vulkan::VkFence__CP >(pFences, *observer->getScratch()), toEncoder< uint32_t >(waitAll, *observer->getScratch()), timeout, result); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| |
| return result; |
| } |
| |
| void VulkanSpy::vkDestroyImageView(CallObserver* observer, VkDevice device, VkImageView imageView, VkAllocationCallbacks* pAllocator) { |
| GAPID_DEBUG("vkDestroyImageView(%zu, %" PRIu64 ", %p)", device, imageView, pAllocator); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkDestroyImageView == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkDestroyImageView"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, device, imageView, pAllocator] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[device].vkDestroyImageView(device, imageView, pAllocator); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| this->ImageViews.erase(imageView); |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkDestroyImageView coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), toEncoder< uint64_t >(imageView, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkAllocationCallbacks__CP >(pAllocator, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkDestroyPipelineLayout(CallObserver* observer, VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks* pAllocator) { |
| GAPID_DEBUG("vkDestroyPipelineLayout(%zu, %" PRIu64 ", %p)", device, pipelineLayout, pAllocator); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkDestroyPipelineLayout == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkDestroyPipelineLayout"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, device, pipelineLayout, pAllocator] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[device].vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| this->PipelineLayouts.erase(pipelineLayout); |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkDestroyPipelineLayout coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), toEncoder< uint64_t >(pipelineLayout, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkAllocationCallbacks__CP >(pAllocator, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| uint32_t VulkanSpy::vkResetCommandPool(CallObserver* observer, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { |
| GAPID_DEBUG("vkResetCommandPool(%zu, %" PRIu64 ", %" PRIu32 ")", device, commandPool, flags); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkResetCommandPool == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkResetCommandPool"); |
| return 0; |
| } |
| |
| uint32_t result = 0; |
| bool called = false; |
| auto call = [this, observer, &called, &result, device, commandPool, flags] { |
| called = true; |
| observer->observeReads(); |
| result = mImports.mVkDeviceFunctions[device].vkResetCommandPool(device, commandPool, flags); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| call(); |
| break; |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkResetCommandPool coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), toEncoder< uint64_t >(commandPool, *observer->getScratch()), toEncoder< uint32_t >(flags, *observer->getScratch()), result); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| |
| return result; |
| } |
| |
| void VulkanSpy::vkFreeCommandBuffers(CallObserver* observer, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, VkCommandBuffer* pCommandBuffers) { |
| GAPID_DEBUG("vkFreeCommandBuffers(%zu, %" PRIu64 ", %" PRIu32 ", %p)", device, commandPool, commandBufferCount, pCommandBuffers); |
| |
| if (mImports.mVkDeviceFunctions.find(device) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[device].vkFreeCommandBuffers == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkFreeCommandBuffers"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, device, commandPool, commandBufferCount, pCommandBuffers] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[device].vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| Slice<VkCommandBuffer> l_cb = slice(pCommandBuffers, (uint64_t)(0UL), (uint64_t)(commandBufferCount)); |
| for (uint32_t l_i = 0UL; l_i < commandBufferCount; ++l_i) { |
| VkCommandBuffer l_buffer = observer->read(l_cb, (uint64_t)(l_i)); |
| this->CommandBuffers.erase(l_buffer); |
| } |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkFreeCommandBuffers coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(device, *observer->getScratch()), toEncoder< uint64_t >(commandPool, *observer->getScratch()), commandBufferCount, toEncoder< gapic::coder::vulkan::VkCommandBuffer__CP >(pCommandBuffers, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkCmdSetViewport(CallObserver* observer, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, VkViewport* pViewports) { |
| GAPID_DEBUG("vkCmdSetViewport(%zu, %" PRIu32 ", %" PRIu32 ", %p)", commandBuffer, firstViewport, viewportCount, pViewports); |
| |
| if (CommandBuffers.find(commandBuffer) == CommandBuffers.end() || |
| mImports.mVkDeviceFunctions.find(CommandBuffers[commandBuffer]->mDevice) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdSetViewport == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCmdSetViewport"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, commandBuffer, firstViewport, viewportCount, pViewports] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| observer->read(slice(pViewports, (uint64_t)(0UL), (uint64_t)(viewportCount))); |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCmdSetViewport coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(commandBuffer, *observer->getScratch()), firstViewport, viewportCount, toEncoder< gapic::coder::vulkan::VkViewport__CP >(pViewports, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkCmdSetScissor(CallObserver* observer, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, VkRect2D* pScissors) { |
| GAPID_DEBUG("vkCmdSetScissor(%zu, %" PRIu32 ", %" PRIu32 ", %p)", commandBuffer, firstScissor, scissorCount, pScissors); |
| |
| if (CommandBuffers.find(commandBuffer) == CommandBuffers.end() || |
| mImports.mVkDeviceFunctions.find(CommandBuffers[commandBuffer]->mDevice) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdSetScissor == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCmdSetScissor"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, commandBuffer, firstScissor, scissorCount, pScissors] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| observer->read(slice(pScissors, (uint64_t)(0UL), (uint64_t)(scissorCount))); |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCmdSetScissor coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(commandBuffer, *observer->getScratch()), firstScissor, scissorCount, toEncoder< gapic::coder::vulkan::VkRect2D__CP >(pScissors, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkCmdDraw(CallObserver* observer, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { |
| GAPID_DEBUG("vkCmdDraw(%zu, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); |
| |
| if (CommandBuffers.find(commandBuffer) == CommandBuffers.end() || |
| mImports.mVkDeviceFunctions.find(CommandBuffers[commandBuffer]->mDevice) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdDraw == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCmdDraw"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| addCmd(observer, commandBuffer, CmdDraw(vertexCount, instanceCount, firstVertex, firstInstance), &VulkanSpy::subDoCmdDraw); |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCmdDraw coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(commandBuffer, *observer->getScratch()), vertexCount, instanceCount, firstVertex, firstInstance); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkCmdDispatch(CallObserver* observer, VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { |
| GAPID_DEBUG("vkCmdDispatch(%zu, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", commandBuffer, x, y, z); |
| |
| if (CommandBuffers.find(commandBuffer) == CommandBuffers.end() || |
| mImports.mVkDeviceFunctions.find(CommandBuffers[commandBuffer]->mDevice) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdDispatch == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCmdDispatch"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, commandBuffer, x, y, z] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdDispatch(commandBuffer, x, y, z); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCmdDispatch coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(commandBuffer, *observer->getScratch()), x, y, z); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| void VulkanSpy::vkCmdCopyImage(CallObserver* observer, VkCommandBuffer commandBuffer, VkImage srcImage, uint32_t srcImageLayout, VkImage dstImage, uint32_t dstImageLayout, uint32_t regionCount, VkImageCopy* pRegions) { |
| GAPID_DEBUG("vkCmdCopyImage(%zu, %" PRIu64 ", %u, %" PRIu64 ", %u, %" PRIu32 ", %p)", commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); |
| |
| if (CommandBuffers.find(commandBuffer) == CommandBuffers.end() || |
| mImports.mVkDeviceFunctions.find(CommandBuffers[commandBuffer]->mDevice) == mImports.mVkDeviceFunctions.end() || |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdCopyImage == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCmdCopyImage"); |
| return; |
| } |
| |
| bool called = false; |
| auto call = [this, observer, &called, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions] { |
| called = true; |
| observer->observeReads(); |
| mImports.mVkDeviceFunctions[CommandBuffers[commandBuffer]->mDevice].vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| Slice<VkImageCopy> l_regions = slice(pRegions, (uint64_t)(0UL), (uint64_t)(regionCount)); |
| CmdCopyImage l_copyArgs = CmdCopyImage(srcImage, dstImage, U64ToVkImageCopy()); |
| for (uint32_t l_i = 0UL; l_i < regionCount; ++l_i) { |
| l_copyArgs.mRegions[(uint64_t)(l_i)] = observer->read(l_regions, (uint64_t)(l_i)); |
| } |
| addCmd(observer, commandBuffer, l_copyArgs, &VulkanSpy::subDoCmdCopyImage); |
| call(); |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCmdCopyImage coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(commandBuffer, *observer->getScratch()), toEncoder< uint64_t >(srcImage, *observer->getScratch()), srcImageLayout, toEncoder< uint64_t >(dstImage, *observer->getScratch()), dstImageLayout, regionCount, toEncoder< gapic::coder::vulkan::VkImageCopy__CP >(pRegions, *observer->getScratch())); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| } |
| |
| uint32_t VulkanSpy::vkCreateDisplayPlaneSurfaceKHR(CallObserver* observer, VkInstance instance, VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { |
| GAPID_DEBUG("vkCreateDisplayPlaneSurfaceKHR(%zu, %p, %p, %p)", instance, pCreateInfo, pAllocator, pSurface); |
| |
| if (mImports.mVkInstanceFunctions.find(instance) == mImports.mVkInstanceFunctions.end() || |
| mImports.mVkInstanceFunctions[instance].vkCreateDisplayPlaneSurfaceKHR == nullptr) { |
| GAPID_WARNING("Application called unsupported function vkCreateDisplayPlaneSurfaceKHR"); |
| return 0; |
| } |
| |
| uint32_t result = 0; |
| bool called = false; |
| auto call = [this, observer, &called, &result, instance, pCreateInfo, pAllocator, pSurface] { |
| called = true; |
| observer->observeReads(); |
| result = mImports.mVkInstanceFunctions[instance].vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| onPostFence(observer); |
| }; |
| |
| |
| uint64_t counter_at_begin = mCommandStartEndCounter++; |
| |
| try { |
| do { |
| (void)observer->read(slice(pCreateInfo, 0ULL, 1ULL), 0ULL); |
| call(); |
| auto l_handle = slice(pSurface, 0ULL, 1ULL)[0ULL]; |
| observer->write<VkSurfaceKHR>(slice(pSurface, 0ULL, 1ULL), 0ULL, l_handle); |
| std::shared_ptr<SurfaceObject> l_surfaceObject = std::shared_ptr<SurfaceObject>(new SurfaceObject(instance, l_handle)); |
| this->Surfaces[l_handle] = l_surfaceObject; |
| break; |
| } while(false); |
| } catch (gapii::AbortException& e) { |
| if (!called) { |
| call(); // abort() was called before the fence. |
| } |
| handleAbort(observer, e); |
| } |
| uint64_t counter_at_end = mCommandStartEndCounter++; |
| gapic::coder::atom::CommandCounter counter_value_encodable(counter_at_begin, counter_at_end); |
| |
| observer->observeWrites(); |
| |
| gapic::coder::vulkan::VkCreateDisplayPlaneSurfaceKHR coder(observer->getScratch()->vector<gapic::Encodable*>(kMaxExtras), toEncoder< size_val >(instance, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkDisplaySurfaceCreateInfoKHR__CP >(pCreateInfo, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkAllocationCallbacks__CP >(pAllocator, *observer->getScratch()), toEncoder< gapic::coder::vulkan::VkSurfaceKHR__P >(pSurface, *observer->getScratch()), result); |
| coder.mextras.append(observer->getExtras()); |
| |
| if (counter_at_end > counter_at_begin + 1 || |
| counter_at_begin != mExpectedNextCommandStartCounterValue) { |
| coder.mextras.append(&counter_value_encodable); |
| } |
| mExpectedNextCommandStartCounterValue = counter_at_end + 1; |
| |
| mEncoder->Variant(&coder); |
| |
| |
| return result; |
| } |
| } // namespace gapii |
