1 // Copyright (C) 2018 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 #include "VulkanStreamGuest.h"
15
16 namespace gfxstream {
17 namespace vk {
18
VulkanStreamGuest(IOStream * stream)19 VulkanStreamGuest::VulkanStreamGuest(IOStream *stream): mStream(stream) {
20 unsetHandleMapping();
21 mFeatureBits = ResourceTracker::get()->getStreamFeatures();
22 }
23
24 VulkanStreamGuest::~VulkanStreamGuest() = default;
25
valid()26 bool VulkanStreamGuest::valid() {
27 return true;
28 }
29
alloc(void ** ptrAddr,size_t bytes)30 void VulkanStreamGuest::alloc(void** ptrAddr, size_t bytes) {
31 if (!bytes) {
32 *ptrAddr = nullptr;
33 return;
34 }
35
36 *ptrAddr = mPool.alloc(bytes);
37 }
38
loadStringInPlace(char ** forOutput)39 void VulkanStreamGuest::loadStringInPlace(char** forOutput) {
40 size_t len = getBe32();
41
42 alloc((void**)forOutput, len + 1);
43
44 memset(*forOutput, 0x0, len + 1);
45
46 if (len > 0) read(*forOutput, len);
47 }
48
loadStringArrayInPlace(char *** forOutput)49 void VulkanStreamGuest::loadStringArrayInPlace(char*** forOutput) {
50 size_t count = getBe32();
51
52 if (!count) {
53 *forOutput = nullptr;
54 return;
55 }
56
57 alloc((void**)forOutput, count * sizeof(char*));
58
59 char **stringsForOutput = *forOutput;
60
61 for (size_t i = 0; i < count; i++) {
62 loadStringInPlace(stringsForOutput + i);
63 }
64 }
65
loadStringInPlaceWithStreamPtr(char ** forOutput,uint8_t ** streamPtr)66 void VulkanStreamGuest::loadStringInPlaceWithStreamPtr(char** forOutput, uint8_t** streamPtr) {
67 uint32_t len;
68 memcpy(&len, *streamPtr, sizeof(uint32_t));
69 *streamPtr += sizeof(uint32_t);
70 android::base::Stream::fromBe32((uint8_t*)&len);
71
72 alloc((void**)forOutput, len + 1);
73
74 memset(*forOutput, 0x0, len + 1);
75
76 if (len > 0) {
77 memcpy(*forOutput, *streamPtr, len);
78 *streamPtr += len;
79 }
80 }
81
loadStringArrayInPlaceWithStreamPtr(char *** forOutput,uint8_t ** streamPtr)82 void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput, uint8_t** streamPtr) {
83 uint32_t count;
84 memcpy(&count, *streamPtr, sizeof(uint32_t));
85 *streamPtr += sizeof(uint32_t);
86 android::base::Stream::fromBe32((uint8_t*)&count);
87 if (!count) {
88 *forOutput = nullptr;
89 return;
90 }
91
92 alloc((void**)forOutput, count * sizeof(char*));
93
94 char **stringsForOutput = *forOutput;
95
96 for (size_t i = 0; i < count; i++) {
97 loadStringInPlaceWithStreamPtr(stringsForOutput + i, streamPtr);
98 }
99 }
100
101
read(void * buffer,size_t size)102 ssize_t VulkanStreamGuest::read(void *buffer, size_t size) {
103 if (!mStream->readback(buffer, size)) {
104 ALOGE("FATAL: Could not read back %zu bytes", size);
105 abort();
106 }
107 return size;
108 }
109
write(const void * buffer,size_t size)110 ssize_t VulkanStreamGuest::write(const void *buffer, size_t size) {
111 uint8_t* streamBuf = (uint8_t*)mStream->alloc(size);
112 memcpy(streamBuf, buffer, size);
113 return size;
114 }
115
writeLarge(const void * buffer,size_t size)116 void VulkanStreamGuest::writeLarge(const void* buffer, size_t size) {
117 mStream->writeFullyAsync(buffer, size);
118 }
119
clearPool()120 void VulkanStreamGuest::clearPool() {
121 mPool.freeAll();
122 }
123
setHandleMapping(VulkanHandleMapping * mapping)124 void VulkanStreamGuest::setHandleMapping(VulkanHandleMapping* mapping) {
125 mCurrentHandleMapping = mapping;
126 }
127
unsetHandleMapping()128 void VulkanStreamGuest::unsetHandleMapping() {
129 mCurrentHandleMapping = &mDefaultHandleMapping;
130 }
131
handleMapping() const132 VulkanHandleMapping* VulkanStreamGuest::handleMapping() const {
133 return mCurrentHandleMapping;
134 }
135
flush()136 void VulkanStreamGuest::flush() {
137 AEMU_SCOPED_TRACE("VulkanStreamGuest device write");
138 mStream->flush();
139 }
140
getFeatureBits() const141 uint32_t VulkanStreamGuest::getFeatureBits() const {
142 return mFeatureBits;
143 }
144
incStreamRef()145 void VulkanStreamGuest::incStreamRef() {
146 mStream->incRef();
147 }
148
decStreamRef()149 bool VulkanStreamGuest::decStreamRef() {
150 return mStream->decRef();
151 }
152
reserve(size_t size)153 uint8_t* VulkanStreamGuest::reserve(size_t size) {
154 return (uint8_t*)mStream->alloc(size);
155 }
156
VulkanCountingStream()157 VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) { }
158 VulkanCountingStream::~VulkanCountingStream() = default;
159
read(void *,size_t size)160 ssize_t VulkanCountingStream::read(void*, size_t size) {
161 m_read += size;
162 return size;
163 }
164
write(const void *,size_t size)165 ssize_t VulkanCountingStream::write(const void*, size_t size) {
166 m_written += size;
167 return size;
168 }
169
rewind()170 void VulkanCountingStream::rewind() {
171 m_written = 0;
172 m_read = 0;
173 }
174
175 } // namespace vk
176 } // namespace gfxstream
177