blob: e13c8f08ffe53e5da4d625bfaa9004c13bdfde52 [file] [log] [blame]
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001// XGL tests
Chia-I Wud7414b02014-10-21 11:06:26 +08002//
Chia-I Wu998c2ac2014-12-08 14:30:10 +08003// Copyright (C) 2014 LunarG, Inc.
Chia-I Wud7414b02014-10-21 11:06:26 +08004//
Chia-I Wu998c2ac2014-12-08 14:30:10 +08005// Permission is hereby granted, free of charge, to any person obtaining a
6// copy of this software and associated documentation files (the "Software"),
7// to deal in the Software without restriction, including without limitation
8// the rights to use, copy, modify, merge, publish, distribute, sublicense,
9// and/or sell copies of the Software, and to permit persons to whom the
10// Software is furnished to do so, subject to the following conditions:
Chia-I Wud7414b02014-10-21 11:06:26 +080011//
Chia-I Wu998c2ac2014-12-08 14:30:10 +080012// The above copyright notice and this permission notice shall be included
13// in all copies or substantial portions of the Software.
Chia-I Wud7414b02014-10-21 11:06:26 +080014//
Chia-I Wu998c2ac2014-12-08 14:30:10 +080015// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21// DEALINGS IN THE SOFTWARE.
Chia-I Wud7414b02014-10-21 11:06:26 +080022
23// Blit (copy, clear, and resolve) tests
24
Chia-I Wua9a506a2014-12-27 22:04:00 +080025#include "test_common.h"
26#include "xgltestbinding.h"
Tony Barbour92400bb2015-03-02 16:38:52 -070027#include "test_environment.h"
Chia-I Wud7414b02014-10-21 11:06:26 +080028
29#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
30
Chia-I Wu998c2ac2014-12-08 14:30:10 +080031namespace xgl_testing {
Chia-I Wud7414b02014-10-21 11:06:26 +080032
Mark Lobodzinski17caf572015-01-29 08:55:56 -060033size_t get_format_size(XGL_FORMAT format);
Chia-I Wu998c2ac2014-12-08 14:30:10 +080034
Chia-I Wu998c2ac2014-12-08 14:30:10 +080035class ImageChecker {
36public:
Chia-I Wu1a28fe02015-01-01 07:55:04 +080037 explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
Chia-I Wu998c2ac2014-12-08 14:30:10 +080038 : info_(info), regions_(regions), pattern_(HASH) {}
39 explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges);
40 explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info);
41
42 void set_solid_pattern(const std::vector<uint8_t> &solid);
43
44 XGL_GPU_SIZE buffer_size() const;
45 bool fill(Buffer &buf) const { return walk(FILL, buf); }
46 bool fill(Image &img) const { return walk(FILL, img); }
47 bool check(Buffer &buf) const { return walk(CHECK, buf); }
48 bool check(Image &img) const { return walk(CHECK, img); }
49
Chia-I Wu1a28fe02015-01-01 07:55:04 +080050 const std::vector<XGL_BUFFER_IMAGE_COPY> &regions() const { return regions_; }
Chia-I Wu998c2ac2014-12-08 14:30:10 +080051
52 static void hash_salt_generate() { hash_salt_++; }
53
54private:
55 enum Action {
56 FILL,
57 CHECK,
58 };
59
60 enum Pattern {
61 HASH,
62 SOLID,
63 };
64
Mark Lobodzinski17caf572015-01-29 08:55:56 -060065 size_t buffer_cpp() const;
Chia-I Wu1a28fe02015-01-01 07:55:04 +080066 XGL_SUBRESOURCE_LAYOUT buffer_layout(const XGL_BUFFER_IMAGE_COPY &region) const;
Chia-I Wu998c2ac2014-12-08 14:30:10 +080067
68 bool walk(Action action, Buffer &buf) const;
69 bool walk(Action action, Image &img) const;
Chia-I Wu1a28fe02015-01-01 07:55:04 +080070 bool walk_region(Action action, const XGL_BUFFER_IMAGE_COPY &region, const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const;
Chia-I Wu998c2ac2014-12-08 14:30:10 +080071
72 std::vector<uint8_t> pattern_hash(const XGL_IMAGE_SUBRESOURCE &subres, const XGL_OFFSET3D &offset) const;
73
74 static uint32_t hash_salt_;
75
76 XGL_IMAGE_CREATE_INFO info_;
Chia-I Wu1a28fe02015-01-01 07:55:04 +080077 std::vector<XGL_BUFFER_IMAGE_COPY> regions_;
Chia-I Wu998c2ac2014-12-08 14:30:10 +080078
79 Pattern pattern_;
80 std::vector<uint8_t> pattern_solid_;
81};
82
Chia-I Wud7414b02014-10-21 11:06:26 +080083
Chia-I Wu998c2ac2014-12-08 14:30:10 +080084uint32_t ImageChecker::hash_salt_;
85
86ImageChecker::ImageChecker(const XGL_IMAGE_CREATE_INFO &info)
87 : info_(info), regions_(), pattern_(HASH)
88{
89 // create a region for every mip level in array slice 0
90 XGL_GPU_SIZE offset = 0;
Mark Lobodzinski17caf572015-01-29 08:55:56 -060091 for (uint32_t lv = 0; lv < info_.mipLevels; lv++) {
Chia-I Wu1a28fe02015-01-01 07:55:04 +080092 XGL_BUFFER_IMAGE_COPY region = {};
Chia-I Wu998c2ac2014-12-08 14:30:10 +080093
Chia-I Wu1a28fe02015-01-01 07:55:04 +080094 region.bufferOffset = offset;
Chia-I Wu998c2ac2014-12-08 14:30:10 +080095 region.imageSubresource.mipLevel = lv;
96 region.imageSubresource.arraySlice = 0;
Chia-I Wua9a506a2014-12-27 22:04:00 +080097 region.imageExtent = Image::extent(info_.extent, lv);
Chia-I Wu998c2ac2014-12-08 14:30:10 +080098
99 if (info_.usage & XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT) {
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700100 if (info_.format != XGL_FMT_S8_UINT) {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800101 region.imageSubresource.aspect = XGL_IMAGE_ASPECT_DEPTH;
102 regions_.push_back(region);
103 }
104
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700105 if (info_.format == XGL_FMT_D16_UNORM_S8_UINT ||
106 info_.format == XGL_FMT_D32_SFLOAT_S8_UINT ||
107 info_.format == XGL_FMT_S8_UINT) {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800108 region.imageSubresource.aspect = XGL_IMAGE_ASPECT_STENCIL;
109 regions_.push_back(region);
110 }
Chia-I Wud7414b02014-10-21 11:06:26 +0800111 } else {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800112 region.imageSubresource.aspect = XGL_IMAGE_ASPECT_COLOR;
113 regions_.push_back(region);
114 }
115
116 offset += buffer_layout(region).size;
117 }
118
119 // arraySize should be limited in our tests. If this proves to be an
120 // issue, we can store only the regions for array slice 0 and be smart.
121 if (info_.arraySize > 1) {
122 const XGL_GPU_SIZE slice_pitch = offset;
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600123 const uint32_t slice_region_count = regions_.size();
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800124
125 regions_.reserve(slice_region_count * info_.arraySize);
126
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600127 for (uint32_t slice = 1; slice < info_.arraySize; slice++) {
128 for (uint32_t i = 0; i < slice_region_count; i++) {
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800129 XGL_BUFFER_IMAGE_COPY region = regions_[i];
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800130
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800131 region.bufferOffset += slice_pitch * slice;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800132 region.imageSubresource.arraySlice = slice;
133 regions_.push_back(region);
134 }
135 }
136 }
137}
138
139ImageChecker::ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
140 : info_(info), regions_(), pattern_(HASH)
141{
142 XGL_GPU_SIZE offset = 0;
143 for (std::vector<XGL_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
144 it != ranges.end(); it++) {
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600145 for (uint32_t lv = 0; lv < it->mipLevels; lv++) {
146 for (uint32_t slice = 0; slice < it->arraySize; slice++) {
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800147 XGL_BUFFER_IMAGE_COPY region = {};
148 region.bufferOffset = offset;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800149 region.imageSubresource = Image::subresource(*it, lv, slice);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800150 region.imageExtent = Image::extent(info_.extent, lv);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800151
152 regions_.push_back(region);
153
154 offset += buffer_layout(region).size;
155 }
156 }
157 }
158}
159
160void ImageChecker::set_solid_pattern(const std::vector<uint8_t> &solid)
161{
162 pattern_ = SOLID;
Chia-I Wu72e34332014-12-21 14:59:04 +0800163 pattern_solid_.clear();
164 pattern_solid_.reserve(buffer_cpp());
165 for (int i = 0; i < buffer_cpp(); i++)
166 pattern_solid_.push_back(solid[i % solid.size()]);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800167}
168
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600169size_t ImageChecker::buffer_cpp() const
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800170{
171 return get_format_size(info_.format);
172}
173
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800174XGL_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const XGL_BUFFER_IMAGE_COPY &region) const
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800175{
176 XGL_SUBRESOURCE_LAYOUT layout = {};
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800177 layout.offset = region.bufferOffset;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800178 layout.rowPitch = buffer_cpp() * region.imageExtent.width;
179 layout.depthPitch = layout.rowPitch * region.imageExtent.height;
180 layout.size = layout.depthPitch * region.imageExtent.depth;
181
182 return layout;
183}
184
185XGL_GPU_SIZE ImageChecker::buffer_size() const
186{
187 XGL_GPU_SIZE size = 0;
188
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800189 for (std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it = regions_.begin();
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800190 it != regions_.end(); it++) {
191 const XGL_SUBRESOURCE_LAYOUT layout = buffer_layout(*it);
192 if (size < layout.offset + layout.size)
193 size = layout.offset + layout.size;
194 }
195
196 return size;
197}
198
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800199bool ImageChecker::walk_region(Action action, const XGL_BUFFER_IMAGE_COPY &region,
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800200 const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const
201{
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600202 for (int32_t z = 0; z < region.imageExtent.depth; z++) {
203 for (int32_t y = 0; y < region.imageExtent.height; y++) {
204 for (int32_t x = 0; x < region.imageExtent.width; x++) {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800205 uint8_t *dst = static_cast<uint8_t *>(data);
206 dst += layout.offset + layout.depthPitch * z +
207 layout.rowPitch * y + buffer_cpp() * x;
208
209 XGL_OFFSET3D offset = region.imageOffset;
210 offset.x += x;
211 offset.y += y;
212 offset.z += z;
213
214 const std::vector<uint8_t> &val = (pattern_ == HASH) ?
215 pattern_hash(region.imageSubresource, offset) :
216 pattern_solid_;
217 assert(val.size() == buffer_cpp());
218
219 if (action == FILL) {
220 memcpy(dst, &val[0], val.size());
221 } else {
222 for (int i = 0; i < val.size(); i++) {
223 EXPECT_EQ(val[i], dst[i]) <<
224 "Offset is: (" << x << ", " << y << ", " << z << ")";
225 if (val[i] != dst[i])
226 return false;
227 }
228 }
229 }
Chia-I Wud7414b02014-10-21 11:06:26 +0800230 }
231 }
232
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800233 return true;
Chia-I Wud7414b02014-10-21 11:06:26 +0800234}
235
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800236bool ImageChecker::walk(Action action, Buffer &buf) const
Chia-I Wu5b22bc72014-11-22 02:51:25 +0800237{
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800238 void *data = buf.map();
239 if (!data)
240 return false;
Chia-I Wu5b22bc72014-11-22 02:51:25 +0800241
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800242 std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800243 for (it = regions_.begin(); it != regions_.end(); it++) {
244 if (!walk_region(action, *it, buffer_layout(*it), data))
245 break;
Chia-I Wu5b22bc72014-11-22 02:51:25 +0800246 }
247
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800248 buf.unmap();
Chia-I Wu5b22bc72014-11-22 02:51:25 +0800249
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800250 return (it == regions_.end());
Chia-I Wu5b22bc72014-11-22 02:51:25 +0800251}
252
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800253bool ImageChecker::walk(Action action, Image &img) const
254{
255 void *data = img.map();
256 if (!data)
257 return false;
258
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800259 std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800260 for (it = regions_.begin(); it != regions_.end(); it++) {
261 if (!walk_region(action, *it, img.subresource_layout(it->imageSubresource), data))
262 break;
263 }
264
265 img.unmap();
266
267 return (it == regions_.end());
268}
269
270std::vector<uint8_t> ImageChecker::pattern_hash(const XGL_IMAGE_SUBRESOURCE &subres, const XGL_OFFSET3D &offset) const
271{
272#define HASH_BYTE(val, b) static_cast<uint8_t>((static_cast<uint32_t>(val) >> (b * 8)) & 0xff)
273#define HASH_BYTES(val) HASH_BYTE(val, 0), HASH_BYTE(val, 1), HASH_BYTE(val, 2), HASH_BYTE(val, 3)
274 const unsigned char input[] = {
275 HASH_BYTES(hash_salt_),
276 HASH_BYTES(subres.mipLevel),
277 HASH_BYTES(subres.arraySlice),
278 HASH_BYTES(offset.x),
279 HASH_BYTES(offset.y),
280 HASH_BYTES(offset.z),
281 };
282 unsigned long hash = 5381;
283
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600284 for (int32_t i = 0; i < ARRAY_SIZE(input); i++)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800285 hash = ((hash << 5) + hash) + input[i];
286
287 const uint8_t output[4] = { HASH_BYTES(hash) };
288#undef HASH_BYTES
289#undef HASH_BYTE
290
Chia-I Wu72e34332014-12-21 14:59:04 +0800291 std::vector<uint8_t> val;
292 val.reserve(buffer_cpp());
293 for (int i = 0; i < buffer_cpp(); i++)
294 val.push_back(output[i % 4]);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800295
296 return val;
297}
298
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600299size_t get_format_size(XGL_FORMAT format)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800300{
301 static const struct format_info {
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600302 size_t size;
303 uint32_t channel_count;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700304 } format_table[XGL_NUM_FMT] = {
305 [XGL_FMT_UNDEFINED] = { 0, 0 },
306 [XGL_FMT_R4G4_UNORM] = { 1, 2 },
307 [XGL_FMT_R4G4_USCALED] = { 1, 2 },
308 [XGL_FMT_R4G4B4A4_UNORM] = { 2, 4 },
309 [XGL_FMT_R4G4B4A4_USCALED] = { 2, 4 },
310 [XGL_FMT_R5G6B5_UNORM] = { 2, 3 },
311 [XGL_FMT_R5G6B5_USCALED] = { 2, 3 },
312 [XGL_FMT_R5G5B5A1_UNORM] = { 2, 4 },
313 [XGL_FMT_R5G5B5A1_USCALED] = { 2, 4 },
314 [XGL_FMT_R8_UNORM] = { 1, 1 },
315 [XGL_FMT_R8_SNORM] = { 1, 1 },
316 [XGL_FMT_R8_USCALED] = { 1, 1 },
317 [XGL_FMT_R8_SSCALED] = { 1, 1 },
318 [XGL_FMT_R8_UINT] = { 1, 1 },
319 [XGL_FMT_R8_SINT] = { 1, 1 },
320 [XGL_FMT_R8_SRGB] = { 1, 1 },
321 [XGL_FMT_R8G8_UNORM] = { 2, 2 },
322 [XGL_FMT_R8G8_SNORM] = { 2, 2 },
323 [XGL_FMT_R8G8_USCALED] = { 2, 2 },
324 [XGL_FMT_R8G8_SSCALED] = { 2, 2 },
325 [XGL_FMT_R8G8_UINT] = { 2, 2 },
326 [XGL_FMT_R8G8_SINT] = { 2, 2 },
327 [XGL_FMT_R8G8_SRGB] = { 2, 2 },
328 [XGL_FMT_R8G8B8_UNORM] = { 3, 3 },
329 [XGL_FMT_R8G8B8_SNORM] = { 3, 3 },
330 [XGL_FMT_R8G8B8_USCALED] = { 3, 3 },
331 [XGL_FMT_R8G8B8_SSCALED] = { 3, 3 },
332 [XGL_FMT_R8G8B8_UINT] = { 3, 3 },
333 [XGL_FMT_R8G8B8_SINT] = { 3, 3 },
334 [XGL_FMT_R8G8B8_SRGB] = { 3, 3 },
335 [XGL_FMT_R8G8B8A8_UNORM] = { 4, 4 },
336 [XGL_FMT_R8G8B8A8_SNORM] = { 4, 4 },
337 [XGL_FMT_R8G8B8A8_USCALED] = { 4, 4 },
338 [XGL_FMT_R8G8B8A8_SSCALED] = { 4, 4 },
339 [XGL_FMT_R8G8B8A8_UINT] = { 4, 4 },
340 [XGL_FMT_R8G8B8A8_SINT] = { 4, 4 },
341 [XGL_FMT_R8G8B8A8_SRGB] = { 4, 4 },
342 [XGL_FMT_R10G10B10A2_UNORM] = { 4, 4 },
343 [XGL_FMT_R10G10B10A2_SNORM] = { 4, 4 },
344 [XGL_FMT_R10G10B10A2_USCALED] = { 4, 4 },
345 [XGL_FMT_R10G10B10A2_SSCALED] = { 4, 4 },
346 [XGL_FMT_R10G10B10A2_UINT] = { 4, 4 },
347 [XGL_FMT_R10G10B10A2_SINT] = { 4, 4 },
348 [XGL_FMT_R16_UNORM] = { 2, 1 },
349 [XGL_FMT_R16_SNORM] = { 2, 1 },
350 [XGL_FMT_R16_USCALED] = { 2, 1 },
351 [XGL_FMT_R16_SSCALED] = { 2, 1 },
352 [XGL_FMT_R16_UINT] = { 2, 1 },
353 [XGL_FMT_R16_SINT] = { 2, 1 },
354 [XGL_FMT_R16_SFLOAT] = { 2, 1 },
355 [XGL_FMT_R16G16_UNORM] = { 4, 2 },
356 [XGL_FMT_R16G16_SNORM] = { 4, 2 },
357 [XGL_FMT_R16G16_USCALED] = { 4, 2 },
358 [XGL_FMT_R16G16_SSCALED] = { 4, 2 },
359 [XGL_FMT_R16G16_UINT] = { 4, 2 },
360 [XGL_FMT_R16G16_SINT] = { 4, 2 },
361 [XGL_FMT_R16G16_SFLOAT] = { 4, 2 },
362 [XGL_FMT_R16G16B16_UNORM] = { 6, 3 },
363 [XGL_FMT_R16G16B16_SNORM] = { 6, 3 },
364 [XGL_FMT_R16G16B16_USCALED] = { 6, 3 },
365 [XGL_FMT_R16G16B16_SSCALED] = { 6, 3 },
366 [XGL_FMT_R16G16B16_UINT] = { 6, 3 },
367 [XGL_FMT_R16G16B16_SINT] = { 6, 3 },
368 [XGL_FMT_R16G16B16_SFLOAT] = { 6, 3 },
369 [XGL_FMT_R16G16B16A16_UNORM] = { 8, 4 },
370 [XGL_FMT_R16G16B16A16_SNORM] = { 8, 4 },
371 [XGL_FMT_R16G16B16A16_USCALED] = { 8, 4 },
372 [XGL_FMT_R16G16B16A16_SSCALED] = { 8, 4 },
373 [XGL_FMT_R16G16B16A16_UINT] = { 8, 4 },
374 [XGL_FMT_R16G16B16A16_SINT] = { 8, 4 },
375 [XGL_FMT_R16G16B16A16_SFLOAT] = { 8, 4 },
376 [XGL_FMT_R32_UINT] = { 4, 1 },
377 [XGL_FMT_R32_SINT] = { 4, 1 },
378 [XGL_FMT_R32_SFLOAT] = { 4, 1 },
379 [XGL_FMT_R32G32_UINT] = { 8, 2 },
380 [XGL_FMT_R32G32_SINT] = { 8, 2 },
381 [XGL_FMT_R32G32_SFLOAT] = { 8, 2 },
382 [XGL_FMT_R32G32B32_UINT] = { 12, 3 },
383 [XGL_FMT_R32G32B32_SINT] = { 12, 3 },
384 [XGL_FMT_R32G32B32_SFLOAT] = { 12, 3 },
385 [XGL_FMT_R32G32B32A32_UINT] = { 16, 4 },
386 [XGL_FMT_R32G32B32A32_SINT] = { 16, 4 },
387 [XGL_FMT_R32G32B32A32_SFLOAT] = { 16, 4 },
388 [XGL_FMT_R64_SFLOAT] = { 8, 1 },
389 [XGL_FMT_R64G64_SFLOAT] = { 16, 2 },
390 [XGL_FMT_R64G64B64_SFLOAT] = { 24, 3 },
391 [XGL_FMT_R64G64B64A64_SFLOAT] = { 32, 4 },
392 [XGL_FMT_R11G11B10_UFLOAT] = { 4, 3 },
393 [XGL_FMT_R9G9B9E5_UFLOAT] = { 4, 3 },
394 [XGL_FMT_D16_UNORM] = { 2, 1 },
395 [XGL_FMT_D24_UNORM] = { 3, 1 },
396 [XGL_FMT_D32_SFLOAT] = { 4, 1 },
397 [XGL_FMT_S8_UINT] = { 1, 1 },
398 [XGL_FMT_D16_UNORM_S8_UINT] = { 3, 2 },
399 [XGL_FMT_D24_UNORM_S8_UINT] = { 4, 2 },
400 [XGL_FMT_D32_SFLOAT_S8_UINT] = { 4, 2 },
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -0700401 [XGL_FMT_BC1_RGB_UNORM] = { 8, 4 },
402 [XGL_FMT_BC1_RGB_SRGB] = { 8, 4 },
403 [XGL_FMT_BC1_RGBA_UNORM] = { 8, 4 },
404 [XGL_FMT_BC1_RGBA_SRGB] = { 8, 4 },
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700405 [XGL_FMT_BC2_UNORM] = { 16, 4 },
406 [XGL_FMT_BC2_SRGB] = { 16, 4 },
407 [XGL_FMT_BC3_UNORM] = { 16, 4 },
408 [XGL_FMT_BC3_SRGB] = { 16, 4 },
409 [XGL_FMT_BC4_UNORM] = { 8, 4 },
410 [XGL_FMT_BC4_SNORM] = { 8, 4 },
411 [XGL_FMT_BC5_UNORM] = { 16, 4 },
412 [XGL_FMT_BC5_SNORM] = { 16, 4 },
413 [XGL_FMT_BC6H_UFLOAT] = { 16, 4 },
414 [XGL_FMT_BC6H_SFLOAT] = { 16, 4 },
415 [XGL_FMT_BC7_UNORM] = { 16, 4 },
416 [XGL_FMT_BC7_SRGB] = { 16, 4 },
417 // TODO: Initialize remaining compressed formats.
418 [XGL_FMT_ETC2_R8G8B8_UNORM] = { 0, 0 },
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -0700419 [XGL_FMT_ETC2_R8G8B8_SRGB] = { 0, 0 },
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700420 [XGL_FMT_ETC2_R8G8B8A1_UNORM] = { 0, 0 },
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -0700421 [XGL_FMT_ETC2_R8G8B8A1_SRGB] = { 0, 0 },
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700422 [XGL_FMT_ETC2_R8G8B8A8_UNORM] = { 0, 0 },
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -0700423 [XGL_FMT_ETC2_R8G8B8A8_SRGB] = { 0, 0 },
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700424 [XGL_FMT_EAC_R11_UNORM] = { 0, 0 },
425 [XGL_FMT_EAC_R11_SNORM] = { 0, 0 },
426 [XGL_FMT_EAC_R11G11_UNORM] = { 0, 0 },
427 [XGL_FMT_EAC_R11G11_SNORM] = { 0, 0 },
428 [XGL_FMT_ASTC_4x4_UNORM] = { 0, 0 },
429 [XGL_FMT_ASTC_4x4_SRGB] = { 0, 0 },
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -0700430 [XGL_FMT_ASTC_5x4_UNORM] = { 0, 0 },
431 [XGL_FMT_ASTC_5x4_SRGB] = { 0, 0 },
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700432 [XGL_FMT_ASTC_5x5_UNORM] = { 0, 0 },
433 [XGL_FMT_ASTC_5x5_SRGB] = { 0, 0 },
434 [XGL_FMT_ASTC_6x5_UNORM] = { 0, 0 },
435 [XGL_FMT_ASTC_6x5_SRGB] = { 0, 0 },
436 [XGL_FMT_ASTC_6x6_UNORM] = { 0, 0 },
437 [XGL_FMT_ASTC_6x6_SRGB] = { 0, 0 },
438 [XGL_FMT_ASTC_8x5_UNORM] = { 0, 0 },
439 [XGL_FMT_ASTC_8x5_SRGB] = { 0, 0 },
440 [XGL_FMT_ASTC_8x6_UNORM] = { 0, 0 },
441 [XGL_FMT_ASTC_8x6_SRGB] = { 0, 0 },
442 [XGL_FMT_ASTC_8x8_UNORM] = { 0, 0 },
443 [XGL_FMT_ASTC_8x8_SRGB] = { 0, 0 },
444 [XGL_FMT_ASTC_10x5_UNORM] = { 0, 0 },
445 [XGL_FMT_ASTC_10x5_SRGB] = { 0, 0 },
446 [XGL_FMT_ASTC_10x6_UNORM] = { 0, 0 },
447 [XGL_FMT_ASTC_10x6_SRGB] = { 0, 0 },
448 [XGL_FMT_ASTC_10x8_UNORM] = { 0, 0 },
449 [XGL_FMT_ASTC_10x8_SRGB] = { 0, 0 },
450 [XGL_FMT_ASTC_10x10_UNORM] = { 0, 0 },
451 [XGL_FMT_ASTC_10x10_SRGB] = { 0, 0 },
452 [XGL_FMT_ASTC_12x10_UNORM] = { 0, 0 },
453 [XGL_FMT_ASTC_12x10_SRGB] = { 0, 0 },
454 [XGL_FMT_ASTC_12x12_UNORM] = { 0, 0 },
455 [XGL_FMT_ASTC_12x12_SRGB] = { 0, 0 },
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -0700456 [XGL_FMT_B4G4R4A4_UNORM] = { 2, 4 },
457 [XGL_FMT_B5G5R5A1_UNORM] = { 2, 4 },
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700458 [XGL_FMT_B5G6R5_UNORM] = { 2, 3 },
459 [XGL_FMT_B5G6R5_USCALED] = { 2, 3 },
460 [XGL_FMT_B8G8R8_UNORM] = { 3, 3 },
461 [XGL_FMT_B8G8R8_SNORM] = { 3, 3 },
462 [XGL_FMT_B8G8R8_USCALED] = { 3, 3 },
463 [XGL_FMT_B8G8R8_SSCALED] = { 3, 3 },
464 [XGL_FMT_B8G8R8_UINT] = { 3, 3 },
465 [XGL_FMT_B8G8R8_SINT] = { 3, 3 },
466 [XGL_FMT_B8G8R8_SRGB] = { 3, 3 },
467 [XGL_FMT_B8G8R8A8_UNORM] = { 4, 4 },
468 [XGL_FMT_B8G8R8A8_SNORM] = { 4, 4 },
469 [XGL_FMT_B8G8R8A8_USCALED] = { 4, 4 },
470 [XGL_FMT_B8G8R8A8_SSCALED] = { 4, 4 },
471 [XGL_FMT_B8G8R8A8_UINT] = { 4, 4 },
472 [XGL_FMT_B8G8R8A8_SINT] = { 4, 4 },
473 [XGL_FMT_B8G8R8A8_SRGB] = { 4, 4 },
474 [XGL_FMT_B10G10R10A2_UNORM] = { 4, 4 },
475 [XGL_FMT_B10G10R10A2_SNORM] = { 4, 4 },
476 [XGL_FMT_B10G10R10A2_USCALED] = { 4, 4 },
477 [XGL_FMT_B10G10R10A2_SSCALED] = { 4, 4 },
478 [XGL_FMT_B10G10R10A2_UINT] = { 4, 4 },
479 [XGL_FMT_B10G10R10A2_SINT] = { 4, 4 },
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800480 };
481
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700482 return format_table[format].size;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800483}
484
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600485XGL_EXTENT3D get_mip_level_extent(const XGL_EXTENT3D &extent, uint32_t mip_level)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800486{
487 const XGL_EXTENT3D ext = {
488 (extent.width >> mip_level) ? extent.width >> mip_level : 1,
489 (extent.height >> mip_level) ? extent.height >> mip_level : 1,
490 (extent.depth >> mip_level) ? extent.depth >> mip_level : 1,
491 };
492
493 return ext;
494}
495
496}; // namespace xgl_testing
497
498namespace {
499
500#define DO(action) ASSERT_EQ(true, action);
501
Tony Barbour92400bb2015-03-02 16:38:52 -0700502static xgl_testing::Environment *environment;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800503
504class XglCmdBlitTest : public ::testing::Test {
505protected:
506 XglCmdBlitTest() :
507 dev_(environment->default_device()),
Chia-I Wua9a506a2014-12-27 22:04:00 +0800508 queue_(*dev_.graphics_queues()[0]),
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700509 cmd_(dev_, xgl_testing::CmdBuffer::create_info(dev_.graphics_queue_node_index_))
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800510 {
511 // make sure every test uses a different pattern
512 xgl_testing::ImageChecker::hash_salt_generate();
513 }
514
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800515 bool submit_and_done()
516 {
Chia-I Wua9a506a2014-12-27 22:04:00 +0800517 queue_.submit(cmd_, mem_refs_);
518 queue_.wait();
519 mem_refs_.clear();
520 return true;
521 }
522
523 void add_memory_ref(const xgl_testing::Object &obj, XGL_FLAGS flags)
524 {
525 const std::vector<XGL_GPU_MEMORY> mems = obj.memories();
526 for (std::vector<XGL_GPU_MEMORY>::const_iterator it = mems.begin(); it != mems.end(); it++) {
527 std::vector<XGL_MEMORY_REF>::iterator ref;
528 for (ref = mem_refs_.begin(); ref != mem_refs_.end(); ref++) {
529 if (ref->mem == *it)
530 break;
531 }
532
533 if (ref == mem_refs_.end()) {
534 XGL_MEMORY_REF tmp = {};
535 tmp.mem = *it;
536 tmp.flags = flags;
537 mem_refs_.push_back(tmp);
538 } else {
539 ref->flags &= flags;
540 }
541 }
542 }
543
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800544 xgl_testing::Device &dev_;
Chia-I Wua9a506a2014-12-27 22:04:00 +0800545 xgl_testing::Queue &queue_;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800546 xgl_testing::CmdBuffer cmd_;
Chia-I Wua9a506a2014-12-27 22:04:00 +0800547
548 std::vector<XGL_MEMORY_REF> mem_refs_;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800549};
550
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800551typedef XglCmdBlitTest XglCmdFillBufferTest;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800552
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800553TEST_F(XglCmdFillBufferTest, Basic)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800554{
555 xgl_testing::Buffer buf;
556
557 buf.init(dev_, 20);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800558 add_memory_ref(buf, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800559
560 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800561 xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
562 xglCmdFillBuffer(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800563 cmd_.end();
564
565 submit_and_done();
566
567 const uint32_t *data = static_cast<const uint32_t *>(buf.map());
568 EXPECT_EQ(0x11111111, data[0]);
569 EXPECT_EQ(0x22222222, data[1]);
570 EXPECT_EQ(0x22222222, data[2]);
571 EXPECT_EQ(0x22222222, data[3]);
572 EXPECT_EQ(0x22222222, data[4]);
573 buf.unmap();
574}
575
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800576TEST_F(XglCmdFillBufferTest, Large)
Chia-I Wud94726f2014-11-23 02:16:45 +0800577{
578 const XGL_GPU_SIZE size = 32 * 1024 * 1024;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800579 xgl_testing::Buffer buf;
Chia-I Wud94726f2014-11-23 02:16:45 +0800580
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800581 buf.init(dev_, size);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800582 add_memory_ref(buf, 0);
Chia-I Wud94726f2014-11-23 02:16:45 +0800583
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800584 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800585 xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
586 xglCmdFillBuffer(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800587 cmd_.end();
Chia-I Wud94726f2014-11-23 02:16:45 +0800588
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800589 submit_and_done();
Chia-I Wud94726f2014-11-23 02:16:45 +0800590
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800591 const uint32_t *data = static_cast<const uint32_t *>(buf.map());
592 XGL_GPU_SIZE offset;
593 for (offset = 0; offset < size / 2; offset += 4)
594 EXPECT_EQ(0x11111111, data[offset / 4]) << "Offset is: " << offset;
595 for (; offset < size; offset += 4)
596 EXPECT_EQ(0x22222222, data[offset / 4]) << "Offset is: " << offset;
597 buf.unmap();
598}
Chia-I Wud94726f2014-11-23 02:16:45 +0800599
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800600TEST_F(XglCmdFillBufferTest, Overlap)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800601{
602 xgl_testing::Buffer buf;
603
604 buf.init(dev_, 64);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800605 add_memory_ref(buf, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800606
607 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800608 xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
609 xglCmdFillBuffer(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800610 cmd_.end();
611
612 submit_and_done();
613
614 const uint32_t *data = static_cast<const uint32_t *>(buf.map());
615 XGL_GPU_SIZE offset;
616 for (offset = 0; offset < 32; offset += 4)
617 EXPECT_EQ(0x11111111, data[offset / 4]) << "Offset is: " << offset;
618 for (; offset < 64; offset += 4)
619 EXPECT_EQ(0x22222222, data[offset / 4]) << "Offset is: " << offset;
620 buf.unmap();
621}
622
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800623TEST_F(XglCmdFillBufferTest, MultiAlignments)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800624{
625 xgl_testing::Buffer bufs[9];
626 XGL_GPU_SIZE size = 4;
627
628 cmd_.begin();
629 for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
630 bufs[i].init(dev_, size);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800631 add_memory_ref(bufs[i], 0);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800632 xglCmdFillBuffer(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800633 size <<= 1;
634 }
635 cmd_.end();
636
637 submit_and_done();
638
639 size = 4;
640 for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
641 const uint32_t *data = static_cast<const uint32_t *>(bufs[i].map());
642 XGL_GPU_SIZE offset;
643 for (offset = 0; offset < size; offset += 4)
644 EXPECT_EQ(0x11111111, data[offset / 4]) << "Buffser is: " << i << "\n" <<
645 "Offset is: " << offset;
646 bufs[i].unmap();
647
648 size <<= 1;
649 }
650}
651
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800652typedef XglCmdBlitTest XglCmdCopyBufferTest;
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800653
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800654TEST_F(XglCmdCopyBufferTest, Basic)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800655{
656 xgl_testing::Buffer src, dst;
657
658 src.init(dev_, 4);
659 uint32_t *data = static_cast<uint32_t *>(src.map());
660 data[0] = 0x11111111;
661 src.unmap();
Chia-I Wua9a506a2014-12-27 22:04:00 +0800662 add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800663
664 dst.init(dev_, 4);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800665 add_memory_ref(dst, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800666
667 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800668 XGL_BUFFER_COPY region = {};
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800669 region.copySize = 4;
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800670 xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800671 cmd_.end();
672
673 submit_and_done();
674
675 data = static_cast<uint32_t *>(dst.map());
676 EXPECT_EQ(0x11111111, data[0]);
677 dst.unmap();
678}
679
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800680TEST_F(XglCmdCopyBufferTest, Large)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800681{
682 const XGL_GPU_SIZE size = 32 * 1024 * 1024;
683 xgl_testing::Buffer src, dst;
684
685 src.init(dev_, size);
686 uint32_t *data = static_cast<uint32_t *>(src.map());
687 XGL_GPU_SIZE offset;
688 for (offset = 0; offset < size; offset += 4)
689 data[offset / 4] = offset;
690 src.unmap();
Chia-I Wua9a506a2014-12-27 22:04:00 +0800691 add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800692
693 dst.init(dev_, size);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800694 add_memory_ref(dst, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800695
696 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800697 XGL_BUFFER_COPY region = {};
Chia-I Wud94726f2014-11-23 02:16:45 +0800698 region.copySize = size;
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800699 xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800700 cmd_.end();
Chia-I Wud94726f2014-11-23 02:16:45 +0800701
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800702 submit_and_done();
Chia-I Wud94726f2014-11-23 02:16:45 +0800703
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800704 data = static_cast<uint32_t *>(dst.map());
705 for (offset = 0; offset < size; offset += 4)
706 EXPECT_EQ(offset, data[offset / 4]);
707 dst.unmap();
Chia-I Wud94726f2014-11-23 02:16:45 +0800708}
709
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800710TEST_F(XglCmdCopyBufferTest, MultiAlignments)
Chia-I Wud7414b02014-10-21 11:06:26 +0800711{
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800712 const XGL_BUFFER_COPY regions[] = {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800713 /* well aligned */
714 { 0, 0, 256 },
715 { 0, 256, 128 },
716 { 0, 384, 64 },
717 { 0, 448, 32 },
718 { 0, 480, 16 },
719 { 0, 496, 8 },
Chia-I Wud7414b02014-10-21 11:06:26 +0800720
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800721 /* ill aligned */
722 { 7, 510, 16 },
723 { 16, 530, 13 },
724 { 32, 551, 16 },
725 { 45, 570, 15 },
726 { 50, 590, 1 },
727 };
728 xgl_testing::Buffer src, dst;
Chia-I Wud7414b02014-10-21 11:06:26 +0800729
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800730 src.init(dev_, 256);
731 uint8_t *data = static_cast<uint8_t *>(src.map());
732 for (int i = 0; i < 256; i++)
733 data[i] = i;
734 src.unmap();
Chia-I Wua9a506a2014-12-27 22:04:00 +0800735 add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wud7414b02014-10-21 11:06:26 +0800736
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800737 dst.init(dev_, 1024);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800738 add_memory_ref(dst, 0);
Chia-I Wud7414b02014-10-21 11:06:26 +0800739
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800740 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800741 xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800742 cmd_.end();
Chia-I Wud7414b02014-10-21 11:06:26 +0800743
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800744 submit_and_done();
Chia-I Wud7414b02014-10-21 11:06:26 +0800745
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800746 data = static_cast<uint8_t *>(dst.map());
747 for (int i = 0; i < ARRAY_SIZE(regions); i++) {
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800748 const XGL_BUFFER_COPY &r = regions[i];
Chia-I Wud7414b02014-10-21 11:06:26 +0800749
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800750 for (int j = 0; j < r.copySize; j++) {
751 EXPECT_EQ(r.srcOffset + j, data[r.destOffset + j]) <<
752 "Region is: " << i << "\n" <<
753 "Offset is: " << r.destOffset + j;
754 }
755 }
756 dst.unmap();
757}
Chia-I Wud7414b02014-10-21 11:06:26 +0800758
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800759TEST_F(XglCmdCopyBufferTest, RAWHazard)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800760{
761 xgl_testing::Buffer bufs[3];
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000762 XGL_EVENT_CREATE_INFO event_info;
763 XGL_EVENT event;
764 XGL_MEMORY_REQUIREMENTS mem_req;
765 size_t data_size = sizeof(mem_req);
766 XGL_RESULT err;
767
768 // typedef struct _XGL_EVENT_CREATE_INFO
769 // {
770 // XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600771 // const void* pNext; // Pointer to next structure
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000772 // XGL_FLAGS flags; // Reserved
773 // } XGL_EVENT_CREATE_INFO;
774 memset(&event_info, 0, sizeof(event_info));
775 event_info.sType = XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO;
776
777 err = xglCreateEvent(dev_.obj(), &event_info, &event);
778 ASSERT_XGL_SUCCESS(err);
779
780 err = xglGetObjectInfo(event, XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
781 &data_size, &mem_req);
782 ASSERT_XGL_SUCCESS(err);
783
784 // XGL_RESULT XGLAPI xglAllocMemory(
785 // XGL_DEVICE device,
786 // const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
787 // XGL_GPU_MEMORY* pMem);
788 XGL_MEMORY_ALLOC_INFO mem_info;
789 XGL_GPU_MEMORY event_mem;
790
791 ASSERT_NE(0, mem_req.size) << "xglGetObjectInfo (Event): Failed - expect events to require memory";
792
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000793 memset(&mem_info, 0, sizeof(mem_info));
794 mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
795 mem_info.allocationSize = mem_req.size;
Jon Ashburn205b4222015-01-20 16:59:42 -0700796 mem_info.memType = mem_req.memType;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000797 mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
Jon Ashburne01ff7a2015-01-20 15:06:59 -0700798 mem_info.memProps = XGL_MEMORY_PROPERTY_SHAREABLE_BIT;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000799 err = xglAllocMemory(dev_.obj(), &mem_info, &event_mem);
800 ASSERT_XGL_SUCCESS(err);
801
Jon Ashburn9b6eae52015-01-15 10:39:19 -0700802 err = xglBindObjectMemory(event, 0, event_mem, 0);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000803 ASSERT_XGL_SUCCESS(err);
804
805 err = xglResetEvent(event);
806 ASSERT_XGL_SUCCESS(err);
Chia-I Wud7414b02014-10-21 11:06:26 +0800807
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800808 for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
809 bufs[i].init(dev_, 4);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800810 add_memory_ref(bufs[i], 0);
Chia-I Wud7414b02014-10-21 11:06:26 +0800811
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800812 uint32_t *data = static_cast<uint32_t *>(bufs[i].map());
813 data[0] = 0x22222222 * (i + 1);
814 bufs[i].unmap();
815 }
816
817 cmd_.begin();
818
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800819 xglCmdFillBuffer(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800820 // is this necessary?
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000821 XGL_BUFFER_MEMORY_BARRIER memory_barrier = bufs[0].buffer_memory_barrier(
822 XGL_MEMORY_OUTPUT_COPY_BIT, XGL_MEMORY_INPUT_COPY_BIT, 0, 4);
Mark Lobodzinski837ef922015-01-29 14:24:14 -0600823 XGL_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000824
Courtney Goeltzenleuchter1e8f3be2015-03-24 18:02:34 -0600825 XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_TRANSFER_COMPLETE };
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000826 XGL_PIPELINE_BARRIER pipeline_barrier = {};
827 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
828 pipeline_barrier.eventCount = 1;
829 pipeline_barrier.pEvents = set_events;
830 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
831 pipeline_barrier.memBarrierCount = 1;
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -0600832 pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000833 xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800834
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800835 XGL_BUFFER_COPY region = {};
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800836 region.copySize = 4;
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800837 xglCmdCopyBuffer(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, &region);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000838
839 memory_barrier = bufs[1].buffer_memory_barrier(
840 XGL_MEMORY_OUTPUT_COPY_BIT, XGL_MEMORY_INPUT_COPY_BIT, 0, 4);
Mark Lobodzinski837ef922015-01-29 14:24:14 -0600841 pmemory_barrier = &memory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000842 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
843 pipeline_barrier.eventCount = 1;
844 pipeline_barrier.pEvents = set_events;
845 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
846 pipeline_barrier.memBarrierCount = 1;
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -0600847 pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000848 xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800849
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800850 xglCmdCopyBuffer(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, &region);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000851
852 /* Use xglCmdSetEvent and xglCmdWaitEvents to test them.
853 * This could be xglCmdPipelineBarrier.
854 */
Courtney Goeltzenleuchter1e8f3be2015-03-24 18:02:34 -0600855 xglCmdSetEvent(cmd_.obj(), event, XGL_PIPE_EVENT_TRANSFER_COMPLETE);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000856
857 // Additional commands could go into the buffer here before the wait.
858
859 memory_barrier = bufs[1].buffer_memory_barrier(
860 XGL_MEMORY_OUTPUT_COPY_BIT, XGL_MEMORY_INPUT_CPU_READ_BIT, 0, 4);
Mark Lobodzinski837ef922015-01-29 14:24:14 -0600861 pmemory_barrier = &memory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000862 XGL_EVENT_WAIT_INFO wait_info = {};
863 wait_info.sType = XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO;
864 wait_info.eventCount = 1;
865 wait_info.pEvents = &event;
866 wait_info.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
867 wait_info.memBarrierCount = 1;
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -0600868 wait_info.ppMemBarriers = (const void **)&pmemory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000869 xglCmdWaitEvents(cmd_.obj(), &wait_info);
870
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800871 cmd_.end();
872
873 submit_and_done();
874
875 const uint32_t *data = static_cast<const uint32_t *>(bufs[2].map());
876 EXPECT_EQ(0x11111111, data[0]);
877 bufs[2].unmap();
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000878
879 // All done with event memory, clean up
Jon Ashburn9b6eae52015-01-15 10:39:19 -0700880 err = xglBindObjectMemory(event, 0, XGL_NULL_HANDLE, 0);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000881 ASSERT_XGL_SUCCESS(err);
882
883 err = xglDestroyObject(event);
884 ASSERT_XGL_SUCCESS(err);
Tobin Ehlis976fc162015-03-26 08:23:25 -0600885
886 err = xglFreeMemory(event_mem);
887 ASSERT_XGL_SUCCESS(err);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800888}
889
890class XglCmdBlitImageTest : public XglCmdBlitTest {
891protected:
892 void init_test_formats(XGL_FLAGS features)
Chia-I Wud7414b02014-10-21 11:06:26 +0800893 {
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700894 first_linear_format_ = XGL_FMT_UNDEFINED;
895 first_optimal_format_ = XGL_FMT_UNDEFINED;
Chia-I Wud7414b02014-10-21 11:06:26 +0800896
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800897 for (std::vector<xgl_testing::Device::Format>::const_iterator it = dev_.formats().begin();
898 it != dev_.formats().end(); it++) {
899 if (it->features & features) {
900 test_formats_.push_back(*it);
Chia-I Wud7414b02014-10-21 11:06:26 +0800901
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800902 if (it->tiling == XGL_LINEAR_TILING &&
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700903 first_linear_format_ == XGL_FMT_UNDEFINED)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800904 first_linear_format_ = it->format;
905 if (it->tiling == XGL_OPTIMAL_TILING &&
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700906 first_optimal_format_ == XGL_FMT_UNDEFINED)
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800907 first_optimal_format_ = it->format;
908 }
909 }
910 }
Chia-I Wud7414b02014-10-21 11:06:26 +0800911
Chia-I Wu5bc27862014-12-22 13:19:08 +0800912 void init_test_formats()
913 {
914 init_test_formats(static_cast<XGL_FLAGS>(-1));
915 }
916
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800917 void fill_src(xgl_testing::Image &img, const xgl_testing::ImageChecker &checker)
918 {
919 if (img.transparent()) {
920 checker.fill(img);
921 return;
Chia-I Wud7414b02014-10-21 11:06:26 +0800922 }
923
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800924 ASSERT_EQ(true, img.copyable());
925
926 xgl_testing::Buffer in_buf;
927 in_buf.init(dev_, checker.buffer_size());
928 checker.fill(in_buf);
929
Chia-I Wua9a506a2014-12-27 22:04:00 +0800930 add_memory_ref(in_buf, XGL_MEMORY_REF_READ_ONLY_BIT);
931 add_memory_ref(img, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800932
933 // copy in and tile
934 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800935 xglCmdCopyBufferToImage(cmd_.obj(), in_buf.obj(), img.obj(),
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800936 checker.regions().size(), &checker.regions()[0]);
937 cmd_.end();
938
939 submit_and_done();
Chia-I Wud7414b02014-10-21 11:06:26 +0800940 }
941
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800942 void check_dst(xgl_testing::Image &img, const xgl_testing::ImageChecker &checker)
Chia-I Wud6479012014-11-22 15:09:42 +0800943 {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800944 if (img.transparent()) {
945 DO(checker.check(img));
946 return;
Chia-I Wud6479012014-11-22 15:09:42 +0800947 }
948
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800949 ASSERT_EQ(true, img.copyable());
950
951 xgl_testing::Buffer out_buf;
952 out_buf.init(dev_, checker.buffer_size());
953
Chia-I Wua9a506a2014-12-27 22:04:00 +0800954 add_memory_ref(img, XGL_MEMORY_REF_READ_ONLY_BIT);
955 add_memory_ref(out_buf, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800956
957 // copy out and linearize
958 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800959 xglCmdCopyImageToBuffer(cmd_.obj(), img.obj(), out_buf.obj(),
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800960 checker.regions().size(), &checker.regions()[0]);
961 cmd_.end();
962
963 submit_and_done();
964
965 DO(checker.check(out_buf));
Chia-I Wud6479012014-11-22 15:09:42 +0800966 }
967
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800968 std::vector<xgl_testing::Device::Format> test_formats_;
969 XGL_FORMAT first_linear_format_;
970 XGL_FORMAT first_optimal_format_;
971};
972
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800973class XglCmdCopyBufferToImageTest : public XglCmdBlitImageTest {
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800974protected:
975 virtual void SetUp()
976 {
977 XglCmdBlitTest::SetUp();
978 init_test_formats(XGL_FORMAT_IMAGE_COPY_BIT);
979 ASSERT_NE(true, test_formats_.empty());
980 }
981
982 void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const xgl_testing::ImageChecker &checker)
983 {
984 xgl_testing::Buffer buf;
985 xgl_testing::Image img;
986
987 buf.init(dev_, checker.buffer_size());
988 checker.fill(buf);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800989 add_memory_ref(buf, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800990
991 img.init(dev_, img_info);
Chia-I Wua9a506a2014-12-27 22:04:00 +0800992 add_memory_ref(img, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800993
994 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800995 xglCmdCopyBufferToImage(cmd_.obj(), buf.obj(), img.obj(),
Chia-I Wu998c2ac2014-12-08 14:30:10 +0800996 checker.regions().size(), &checker.regions()[0]);
997 cmd_.end();
998
999 submit_and_done();
1000
1001 check_dst(img, checker);
1002 }
1003
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001004 void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001005 {
1006 xgl_testing::ImageChecker checker(img_info, regions);
1007 test_copy_memory_to_image(img_info, checker);
1008 }
1009
1010 void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info)
1011 {
1012 xgl_testing::ImageChecker checker(img_info);
1013 test_copy_memory_to_image(img_info, checker);
1014 }
1015};
1016
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001017TEST_F(XglCmdCopyBufferToImageTest, Basic)
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001018{
1019 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1020 it != test_formats_.end(); it++) {
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001021
1022 // not sure what to do here
1023 if (it->format == XGL_FMT_UNDEFINED ||
1024 (it->format >= XGL_FMT_B8G8R8_UNORM &&
1025 it->format <= XGL_FMT_B8G8R8_SRGB))
1026 continue;
1027
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001028 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1029 img_info.imageType = XGL_IMAGE_2D;
1030 img_info.format = it->format;
1031 img_info.extent.width = 64;
1032 img_info.extent.height = 64;
1033 img_info.tiling = it->tiling;
1034
1035 test_copy_memory_to_image(img_info);
1036 }
Chia-I Wud6479012014-11-22 15:09:42 +08001037}
1038
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001039class XglCmdCopyImageToBufferTest : public XglCmdBlitImageTest {
Chia-I Wu42b97b82014-12-13 15:28:20 +08001040protected:
1041 virtual void SetUp()
1042 {
1043 XglCmdBlitTest::SetUp();
1044 init_test_formats(XGL_FORMAT_IMAGE_COPY_BIT);
1045 ASSERT_NE(true, test_formats_.empty());
1046 }
1047
1048 void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const xgl_testing::ImageChecker &checker)
1049 {
1050 xgl_testing::Image img;
1051 xgl_testing::Buffer buf;
1052
1053 img.init(dev_, img_info);
1054 fill_src(img, checker);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001055 add_memory_ref(img, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wu42b97b82014-12-13 15:28:20 +08001056
1057 buf.init(dev_, checker.buffer_size());
Chia-I Wua9a506a2014-12-27 22:04:00 +08001058 add_memory_ref(buf, 0);
Chia-I Wu42b97b82014-12-13 15:28:20 +08001059
1060 cmd_.begin();
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001061 xglCmdCopyImageToBuffer(cmd_.obj(), img.obj(), buf.obj(),
Chia-I Wu42b97b82014-12-13 15:28:20 +08001062 checker.regions().size(), &checker.regions()[0]);
1063 cmd_.end();
1064
1065 submit_and_done();
1066
1067 checker.check(buf);
1068 }
1069
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001070 void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
Chia-I Wu42b97b82014-12-13 15:28:20 +08001071 {
1072 xgl_testing::ImageChecker checker(img_info, regions);
1073 test_copy_image_to_memory(img_info, checker);
1074 }
1075
1076 void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info)
1077 {
1078 xgl_testing::ImageChecker checker(img_info);
1079 test_copy_image_to_memory(img_info, checker);
1080 }
1081};
1082
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001083TEST_F(XglCmdCopyImageToBufferTest, Basic)
Chia-I Wu42b97b82014-12-13 15:28:20 +08001084{
1085 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1086 it != test_formats_.end(); it++) {
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001087
1088 // not sure what to do here
1089 if (it->format == XGL_FMT_UNDEFINED ||
1090 (it->format >= XGL_FMT_B8G8R8_UNORM &&
1091 it->format <= XGL_FMT_B8G8R8_SRGB))
1092 continue;
1093
Chia-I Wu42b97b82014-12-13 15:28:20 +08001094 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1095 img_info.imageType = XGL_IMAGE_2D;
1096 img_info.format = it->format;
1097 img_info.extent.width = 64;
1098 img_info.extent.height = 64;
1099 img_info.tiling = it->tiling;
1100
1101 test_copy_image_to_memory(img_info);
1102 }
1103}
1104
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001105class XglCmdCopyImageTest : public XglCmdBlitImageTest {
1106protected:
1107 virtual void SetUp()
1108 {
1109 XglCmdBlitTest::SetUp();
1110 init_test_formats(XGL_FORMAT_IMAGE_COPY_BIT);
1111 ASSERT_NE(true, test_formats_.empty());
Chia-I Wu89078aa2014-11-22 16:24:41 +08001112 }
1113
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001114 void test_copy_image(const XGL_IMAGE_CREATE_INFO &src_info, const XGL_IMAGE_CREATE_INFO &dst_info,
1115 const std::vector<XGL_IMAGE_COPY> &copies)
Chia-I Wu89078aa2014-11-22 16:24:41 +08001116 {
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001117 // convert XGL_IMAGE_COPY to two sets of XGL_BUFFER_IMAGE_COPY
1118 std::vector<XGL_BUFFER_IMAGE_COPY> src_regions, dst_regions;
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001119 XGL_GPU_SIZE src_offset = 0, dst_offset = 0;
1120 for (std::vector<XGL_IMAGE_COPY>::const_iterator it = copies.begin(); it != copies.end(); it++) {
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001121 XGL_BUFFER_IMAGE_COPY src_region = {}, dst_region = {};
Chia-I Wu89078aa2014-11-22 16:24:41 +08001122
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001123 src_region.bufferOffset = src_offset;
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001124 src_region.imageSubresource = it->srcSubresource;
1125 src_region.imageOffset = it->srcOffset;
1126 src_region.imageExtent = it->extent;
1127 src_regions.push_back(src_region);
Chia-I Wu89078aa2014-11-22 16:24:41 +08001128
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001129 dst_region.bufferOffset = src_offset;
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001130 dst_region.imageSubresource = it->destSubresource;
1131 dst_region.imageOffset = it->destOffset;
1132 dst_region.imageExtent = it->extent;
1133 dst_regions.push_back(dst_region);
Chia-I Wu89078aa2014-11-22 16:24:41 +08001134
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001135 const XGL_GPU_SIZE size = it->extent.width * it->extent.height * it->extent.depth;
1136 src_offset += xgl_testing::get_format_size(src_info.format) * size;
1137 dst_offset += xgl_testing::get_format_size(dst_info.format) * size;
1138 }
Chia-I Wu89078aa2014-11-22 16:24:41 +08001139
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001140 xgl_testing::ImageChecker src_checker(src_info, src_regions);
1141 xgl_testing::ImageChecker dst_checker(dst_info, dst_regions);
1142
1143 xgl_testing::Image src;
1144 src.init(dev_, src_info);
1145 fill_src(src, src_checker);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001146 add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001147
1148 xgl_testing::Image dst;
1149 dst.init(dev_, dst_info);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001150 add_memory_ref(dst, 0);
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001151
1152 cmd_.begin();
1153 xglCmdCopyImage(cmd_.obj(), src.obj(), dst.obj(), copies.size(), &copies[0]);
1154 cmd_.end();
1155
1156 submit_and_done();
1157
1158 check_dst(dst, dst_checker);
1159 }
1160};
1161
1162TEST_F(XglCmdCopyImageTest, Basic)
1163{
1164 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1165 it != test_formats_.end(); it++) {
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001166
1167 // not sure what to do here
1168 if (it->format == XGL_FMT_UNDEFINED ||
1169 (it->format >= XGL_FMT_B8G8R8_UNORM &&
1170 it->format <= XGL_FMT_B8G8R8_SRGB))
1171 continue;
1172
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001173 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1174 img_info.imageType = XGL_IMAGE_2D;
1175 img_info.format = it->format;
1176 img_info.extent.width = 64;
1177 img_info.extent.height = 64;
1178 img_info.tiling = it->tiling;
1179
1180 XGL_IMAGE_COPY copy = {};
1181 copy.srcSubresource = xgl_testing::Image::subresource(XGL_IMAGE_ASPECT_COLOR, 0, 0);
1182 copy.destSubresource = copy.srcSubresource;
1183 copy.extent = img_info.extent;
1184
1185 test_copy_image(img_info, img_info, std::vector<XGL_IMAGE_COPY>(&copy, &copy + 1));
1186 }
1187}
1188
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001189class XglCmdCloneImageDataTest : public XglCmdBlitImageTest {
1190protected:
1191 virtual void SetUp()
1192 {
1193 XglCmdBlitTest::SetUp();
1194 init_test_formats();
1195 ASSERT_NE(true, test_formats_.empty());
1196 }
1197
1198 void test_clone_image_data(const XGL_IMAGE_CREATE_INFO &img_info)
1199 {
1200 xgl_testing::ImageChecker checker(img_info);
1201 xgl_testing::Image src, dst;
1202
1203 src.init(dev_, img_info);
1204 if (src.transparent() || src.copyable())
1205 fill_src(src, checker);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001206 add_memory_ref(src, XGL_MEMORY_REF_READ_ONLY_BIT);
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001207
1208 dst.init(dev_, img_info);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001209 add_memory_ref(dst, 0);
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001210
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001211 const XGL_IMAGE_LAYOUT layout = XGL_IMAGE_LAYOUT_GENERAL;
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001212
1213 cmd_.begin();
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001214 xglCmdCloneImageData(cmd_.obj(), src.obj(), layout, dst.obj(), layout);
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001215 cmd_.end();
1216
1217 submit_and_done();
1218
1219 // cannot verify
1220 if (!dst.transparent() && !dst.copyable())
1221 return;
1222
1223 check_dst(dst, checker);
1224 }
1225};
1226
1227TEST_F(XglCmdCloneImageDataTest, Basic)
1228{
1229 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1230 it != test_formats_.end(); it++) {
1231 // not sure what to do here
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001232 if (it->format == XGL_FMT_UNDEFINED ||
1233 (it->format >= XGL_FMT_R32G32B32_UINT &&
1234 it->format <= XGL_FMT_R32G32B32_SFLOAT) ||
1235 (it->format >= XGL_FMT_B8G8R8_UNORM &&
1236 it->format <= XGL_FMT_B8G8R8_SRGB) ||
Courtney Goeltzenleuchter3654d602015-03-03 11:30:36 -07001237 (it->format >= XGL_FMT_BC1_RGB_UNORM &&
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001238 it->format <= XGL_FMT_ASTC_12x12_SRGB) ||
1239 (it->format >= XGL_FMT_D16_UNORM &&
1240 it->format <= XGL_FMT_D32_SFLOAT_S8_UINT) ||
1241 it->format == XGL_FMT_R64G64B64_SFLOAT ||
1242 it->format == XGL_FMT_R64G64B64A64_SFLOAT)
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001243 continue;
1244
1245 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1246 img_info.imageType = XGL_IMAGE_2D;
1247 img_info.format = it->format;
1248 img_info.extent.width = 64;
1249 img_info.extent.height = 64;
1250 img_info.tiling = it->tiling;
1251 img_info.flags = XGL_IMAGE_CREATE_CLONEABLE_BIT;
1252
1253 const XGL_IMAGE_SUBRESOURCE_RANGE range =
Chia-I Wua9a506a2014-12-27 22:04:00 +08001254 xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_COLOR);
Chia-I Wu2bb96ef2014-12-22 14:46:56 +08001255 std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
1256
1257 test_clone_image_data(img_info);
1258 }
1259}
1260
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001261class XglCmdClearColorImageTest : public XglCmdBlitImageTest {
1262protected:
Chia-I Wu5bc27862014-12-22 13:19:08 +08001263 XglCmdClearColorImageTest() : test_raw_(false) {}
1264 XglCmdClearColorImageTest(bool test_raw) : test_raw_(test_raw) {}
1265
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001266 virtual void SetUp()
1267 {
1268 XglCmdBlitTest::SetUp();
Chia-I Wu5bc27862014-12-22 13:19:08 +08001269
1270 if (test_raw_)
1271 init_test_formats();
1272 else
1273 init_test_formats(XGL_FORMAT_CONVERSION_BIT);
1274
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001275 ASSERT_NE(true, test_formats_.empty());
1276 }
1277
Chia-I Wu5bc27862014-12-22 13:19:08 +08001278 union Color {
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001279 float color[4];
1280 uint32_t raw[4];
Chia-I Wu5bc27862014-12-22 13:19:08 +08001281 };
1282
1283 bool test_raw_;
1284
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001285 std::vector<uint8_t> color_to_raw(XGL_FORMAT format, const float color[4])
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001286 {
1287 std::vector<uint8_t> raw;
1288
1289 // TODO support all formats
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001290 switch (format) {
1291 case XGL_FMT_R8G8B8A8_UNORM:
1292 raw.push_back(color[0] * 255.0f);
1293 raw.push_back(color[1] * 255.0f);
1294 raw.push_back(color[2] * 255.0f);
1295 raw.push_back(color[3] * 255.0f);
1296 break;
1297 case XGL_FMT_B8G8R8A8_UNORM:
1298 raw.push_back(color[2] * 255.0f);
1299 raw.push_back(color[1] * 255.0f);
1300 raw.push_back(color[0] * 255.0f);
1301 raw.push_back(color[3] * 255.0f);
1302 break;
1303 default:
1304 break;
Chia-I Wu89078aa2014-11-22 16:24:41 +08001305 }
1306
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001307 return raw;
Chia-I Wu89078aa2014-11-22 16:24:41 +08001308 }
Chia-I Wu89078aa2014-11-22 16:24:41 +08001309
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001310 std::vector<uint8_t> color_to_raw(XGL_FORMAT format, const uint32_t color[4])
Chia-I Wu5bc27862014-12-22 13:19:08 +08001311 {
1312 std::vector<uint8_t> raw;
1313
1314 // TODO support all formats
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001315 switch (format) {
1316 case XGL_FMT_R8G8B8A8_UNORM:
1317 raw.push_back(static_cast<uint8_t>(color[0]));
1318 raw.push_back(static_cast<uint8_t>(color[1]));
1319 raw.push_back(static_cast<uint8_t>(color[2]));
1320 raw.push_back(static_cast<uint8_t>(color[3]));
1321 break;
1322 case XGL_FMT_B8G8R8A8_UNORM:
1323 raw.push_back(static_cast<uint8_t>(color[2]));
1324 raw.push_back(static_cast<uint8_t>(color[1]));
1325 raw.push_back(static_cast<uint8_t>(color[0]));
1326 raw.push_back(static_cast<uint8_t>(color[3]));
1327 break;
1328 default:
1329 break;
Chia-I Wu5bc27862014-12-22 13:19:08 +08001330 }
1331
1332 return raw;
1333 }
1334
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001335 std::vector<uint8_t> color_to_raw(XGL_FORMAT format, const XGL_CLEAR_COLOR &color)
Chia-I Wu5bc27862014-12-22 13:19:08 +08001336 {
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001337 if (color.useRawValue)
1338 return color_to_raw(format, color.color.rawColor);
Chia-I Wu5bc27862014-12-22 13:19:08 +08001339 else
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001340 return color_to_raw(format, color.color.floatColor);
Chia-I Wu5bc27862014-12-22 13:19:08 +08001341 }
1342
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001343 void test_clear_color_image(const XGL_IMAGE_CREATE_INFO &img_info,
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001344 const XGL_CLEAR_COLOR &clear_color,
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001345 const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
Chia-I Wud7414b02014-10-21 11:06:26 +08001346 {
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001347 xgl_testing::Image img;
1348 img.init(dev_, img_info);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001349 add_memory_ref(img, 0);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001350 const XGL_FLAGS all_cache_outputs =
1351 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
1352 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
1353 XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
1354 XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1355 XGL_MEMORY_OUTPUT_COPY_BIT;
1356 const XGL_FLAGS all_cache_inputs =
1357 XGL_MEMORY_INPUT_CPU_READ_BIT |
1358 XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
1359 XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
1360 XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
1361 XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
1362 XGL_MEMORY_INPUT_SHADER_READ_BIT |
1363 XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
1364 XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1365 XGL_MEMORY_INPUT_COPY_BIT;
Chia-I Wud7414b02014-10-21 11:06:26 +08001366
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001367 std::vector<XGL_IMAGE_MEMORY_BARRIER> to_clear;
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001368 std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_clear;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001369 std::vector<XGL_IMAGE_MEMORY_BARRIER> to_xfer;
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001370 std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_xfer;
Chia-I Wud7414b02014-10-21 11:06:26 +08001371
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001372 for (std::vector<XGL_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
1373 it != ranges.end(); it++) {
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001374 to_clear.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
1375 XGL_IMAGE_LAYOUT_GENERAL,
1376 XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
1377 *it));
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001378 p_to_clear.push_back(&to_clear.back());
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001379 to_xfer.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
1380 XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
1381 XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001382 p_to_xfer.push_back(&to_xfer.back());
Chia-I Wud7414b02014-10-21 11:06:26 +08001383 }
1384
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001385 cmd_.begin();
Chia-I Wu5bc27862014-12-22 13:19:08 +08001386
Courtney Goeltzenleuchter1e8f3be2015-03-24 18:02:34 -06001387 XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001388 XGL_PIPELINE_BARRIER pipeline_barrier = {};
1389 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
1390 pipeline_barrier.eventCount = 1;
1391 pipeline_barrier.pEvents = set_events;
1392 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
1393 pipeline_barrier.memBarrierCount = to_clear.size();
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -06001394 pipeline_barrier.ppMemBarriers = (const void **)&p_to_clear[0];
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001395 xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
1396
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001397 xglCmdClearColorImage(cmd_.obj(), img.obj(), clear_color, ranges.size(), &ranges[0]);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001398
1399 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
1400 pipeline_barrier.eventCount = 1;
1401 pipeline_barrier.pEvents = set_events;
1402 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
1403 pipeline_barrier.memBarrierCount = to_xfer.size();
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -06001404 pipeline_barrier.ppMemBarriers = (const void **)&p_to_xfer[0];
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001405 xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
Chia-I Wu5bc27862014-12-22 13:19:08 +08001406
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001407 cmd_.end();
1408
1409 submit_and_done();
1410
1411 // cannot verify
1412 if (!img.transparent() && !img.copyable())
1413 return;
1414
1415 xgl_testing::ImageChecker checker(img_info, ranges);
1416
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001417 const std::vector<uint8_t> solid_pattern = color_to_raw(img_info.format, clear_color);
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001418 if (solid_pattern.empty())
1419 return;
1420
1421 checker.set_solid_pattern(solid_pattern);
1422 check_dst(img, checker);
1423 }
Chia-I Wu5bc27862014-12-22 13:19:08 +08001424
1425 void test_clear_color_image(const XGL_IMAGE_CREATE_INFO &img_info,
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001426 const float color[4],
Chia-I Wu5bc27862014-12-22 13:19:08 +08001427 const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
1428 {
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001429 XGL_CLEAR_COLOR c = {};
1430 memcpy(c.color.floatColor, color, sizeof(c.color.floatColor));
Chia-I Wu5bc27862014-12-22 13:19:08 +08001431 test_clear_color_image(img_info, c, ranges);
1432 }
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001433};
1434
1435TEST_F(XglCmdClearColorImageTest, Basic)
1436{
1437 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1438 it != test_formats_.end(); it++) {
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001439 const float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001440
1441 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1442 img_info.imageType = XGL_IMAGE_2D;
1443 img_info.format = it->format;
1444 img_info.extent.width = 64;
1445 img_info.extent.height = 64;
1446 img_info.tiling = it->tiling;
1447
1448 const XGL_IMAGE_SUBRESOURCE_RANGE range =
Chia-I Wua9a506a2014-12-27 22:04:00 +08001449 xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_COLOR);
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001450 std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
1451
1452 test_clear_color_image(img_info, color, ranges);
Chia-I Wud7414b02014-10-21 11:06:26 +08001453 }
1454}
1455
Chia-I Wud6422382014-12-22 13:44:24 +08001456class XglCmdClearColorImageRawTest : public XglCmdClearColorImageTest {
1457protected:
1458 XglCmdClearColorImageRawTest() : XglCmdClearColorImageTest(true) {}
1459
1460 void test_clear_color_image_raw(const XGL_IMAGE_CREATE_INFO &img_info,
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001461 const uint32_t color[4],
Chia-I Wud6422382014-12-22 13:44:24 +08001462 const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
1463 {
Courtney Goeltzenleuchterd462fba2015-04-03 16:35:32 -06001464 XGL_CLEAR_COLOR c = {};
1465 c.useRawValue = true;
1466 memcpy(c.color.rawColor, color, sizeof(c.color.rawColor));
Chia-I Wud6422382014-12-22 13:44:24 +08001467 test_clear_color_image(img_info, c, ranges);
1468 }
1469};
1470
1471TEST_F(XglCmdClearColorImageRawTest, Basic)
1472{
1473 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1474 it != test_formats_.end(); it++) {
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001475 const uint32_t color[4] = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
Chia-I Wud6422382014-12-22 13:44:24 +08001476
1477 // not sure what to do here
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001478 if (it->format == XGL_FMT_UNDEFINED ||
1479 (it->format >= XGL_FMT_R8G8B8_UNORM &&
1480 it->format <= XGL_FMT_R8G8B8_SRGB) ||
1481 (it->format >= XGL_FMT_B8G8R8_UNORM &&
1482 it->format <= XGL_FMT_B8G8R8_SRGB) ||
1483 (it->format >= XGL_FMT_R16G16B16_UNORM &&
1484 it->format <= XGL_FMT_R16G16B16_SFLOAT) ||
1485 (it->format >= XGL_FMT_R32G32B32_UINT &&
1486 it->format <= XGL_FMT_R32G32B32_SFLOAT) ||
1487 it->format == XGL_FMT_R64G64B64_SFLOAT ||
1488 it->format == XGL_FMT_R64G64B64A64_SFLOAT ||
1489 (it->format >= XGL_FMT_D16_UNORM &&
1490 it->format <= XGL_FMT_D32_SFLOAT_S8_UINT))
Chia-I Wud6422382014-12-22 13:44:24 +08001491 continue;
1492
1493 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1494 img_info.imageType = XGL_IMAGE_2D;
1495 img_info.format = it->format;
1496 img_info.extent.width = 64;
1497 img_info.extent.height = 64;
1498 img_info.tiling = it->tiling;
1499
1500 const XGL_IMAGE_SUBRESOURCE_RANGE range =
Chia-I Wua9a506a2014-12-27 22:04:00 +08001501 xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_COLOR);
Chia-I Wud6422382014-12-22 13:44:24 +08001502 std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
1503
1504 test_clear_color_image_raw(img_info, color, ranges);
1505 }
1506}
1507
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001508class XglCmdClearDepthStencilTest : public XglCmdBlitImageTest {
1509protected:
1510 virtual void SetUp()
1511 {
1512 XglCmdBlitTest::SetUp();
1513 init_test_formats(XGL_FORMAT_DEPTH_ATTACHMENT_BIT |
1514 XGL_FORMAT_STENCIL_ATTACHMENT_BIT);
1515 ASSERT_NE(true, test_formats_.empty());
1516 }
1517
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001518 std::vector<uint8_t> ds_to_raw(XGL_FORMAT format, float depth, uint32_t stencil)
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001519 {
1520 std::vector<uint8_t> raw;
1521
1522 // depth
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001523 switch (format) {
1524 case XGL_FMT_D16_UNORM:
1525 case XGL_FMT_D16_UNORM_S8_UINT:
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001526 {
1527 const uint16_t unorm = depth * 65535.0f;
1528 raw.push_back(unorm & 0xff);
1529 raw.push_back(unorm >> 8);
1530 }
1531 break;
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001532 case XGL_FMT_D32_SFLOAT:
1533 case XGL_FMT_D32_SFLOAT_S8_UINT:
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001534 {
1535 const union {
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001536 float depth;
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001537 uint32_t u32;
1538 } u = { depth };
1539
1540 raw.push_back((u.u32 ) & 0xff);
1541 raw.push_back((u.u32 >> 8) & 0xff);
1542 raw.push_back((u.u32 >> 16) & 0xff);
1543 raw.push_back((u.u32 >> 24) & 0xff);
1544 }
1545 break;
1546 default:
1547 break;
1548 }
1549
1550 // stencil
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001551 switch (format) {
1552 case XGL_FMT_S8_UINT:
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001553 raw.push_back(stencil);
1554 break;
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001555 case XGL_FMT_D16_UNORM_S8_UINT:
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001556 raw.push_back(stencil);
1557 raw.push_back(0);
1558 break;
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001559 case XGL_FMT_D32_SFLOAT_S8_UINT:
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001560 raw.push_back(stencil);
1561 raw.push_back(0);
1562 raw.push_back(0);
1563 raw.push_back(0);
1564 break;
1565 default:
1566 break;
1567 }
1568
1569 return raw;
1570 }
1571
1572 void test_clear_depth_stencil(const XGL_IMAGE_CREATE_INFO &img_info,
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001573 float depth, uint32_t stencil,
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001574 const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges)
1575 {
1576 xgl_testing::Image img;
1577 img.init(dev_, img_info);
Chia-I Wua9a506a2014-12-27 22:04:00 +08001578 add_memory_ref(img, 0);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001579 const XGL_FLAGS all_cache_outputs =
1580 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
1581 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
1582 XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
1583 XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1584 XGL_MEMORY_OUTPUT_COPY_BIT;
1585 const XGL_FLAGS all_cache_inputs =
1586 XGL_MEMORY_INPUT_CPU_READ_BIT |
1587 XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
1588 XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
1589 XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
1590 XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
1591 XGL_MEMORY_INPUT_SHADER_READ_BIT |
1592 XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
1593 XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1594 XGL_MEMORY_INPUT_COPY_BIT;
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001595
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001596 std::vector<XGL_IMAGE_MEMORY_BARRIER> to_clear;
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001597 std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_clear;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001598 std::vector<XGL_IMAGE_MEMORY_BARRIER> to_xfer;
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001599 std::vector<XGL_IMAGE_MEMORY_BARRIER *> p_to_xfer;
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001600
1601 for (std::vector<XGL_IMAGE_SUBRESOURCE_RANGE>::const_iterator it = ranges.begin();
1602 it != ranges.end(); it++) {
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001603 to_clear.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
1604 XGL_IMAGE_LAYOUT_GENERAL,
1605 XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
1606 *it));
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001607 p_to_clear.push_back(&to_clear.back());
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001608 to_xfer.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
1609 XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
1610 XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001611 p_to_xfer.push_back(&to_xfer.back());
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001612 }
1613
1614 cmd_.begin();
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001615
Courtney Goeltzenleuchter1e8f3be2015-03-24 18:02:34 -06001616 XGL_PIPE_EVENT set_events[] = { XGL_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001617 XGL_PIPELINE_BARRIER pipeline_barrier = {};
1618 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
1619 pipeline_barrier.eventCount = 1;
1620 pipeline_barrier.pEvents = set_events;
1621 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
1622 pipeline_barrier.memBarrierCount = to_clear.size();
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -06001623 pipeline_barrier.ppMemBarriers = (const void **)&p_to_clear[0];
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001624 xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
1625
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001626 xglCmdClearDepthStencil(cmd_.obj(), img.obj(), depth, stencil, ranges.size(), &ranges[0]);
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001627
1628 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
1629 pipeline_barrier.eventCount = 1;
1630 pipeline_barrier.pEvents = set_events;
1631 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
1632 pipeline_barrier.memBarrierCount = to_xfer.size();
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -06001633 pipeline_barrier.ppMemBarriers = (const void **)&p_to_xfer[0];
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001634 xglCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
1635
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001636 cmd_.end();
1637
1638 submit_and_done();
1639
1640 // cannot verify
1641 if (!img.transparent() && !img.copyable())
1642 return;
1643
1644 xgl_testing::ImageChecker checker(img_info, ranges);
1645
1646 checker.set_solid_pattern(ds_to_raw(img_info.format, depth, stencil));
1647 check_dst(img, checker);
1648 }
1649};
1650
1651TEST_F(XglCmdClearDepthStencilTest, Basic)
1652{
1653 for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
1654 it != test_formats_.end(); it++) {
1655 // known driver issues
Jeremy Hayesa058eee2015-01-23 08:51:43 -07001656 if (it->format == XGL_FMT_S8_UINT ||
1657 it->format == XGL_FMT_D24_UNORM ||
1658 it->format == XGL_FMT_D16_UNORM_S8_UINT ||
1659 it->format == XGL_FMT_D24_UNORM_S8_UINT)
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001660 continue;
1661
1662 XGL_IMAGE_CREATE_INFO img_info = xgl_testing::Image::create_info();
1663 img_info.imageType = XGL_IMAGE_2D;
1664 img_info.format = it->format;
1665 img_info.extent.width = 64;
1666 img_info.extent.height = 64;
1667 img_info.tiling = it->tiling;
1668 img_info.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT;
1669
1670 const XGL_IMAGE_SUBRESOURCE_RANGE range =
Chia-I Wua9a506a2014-12-27 22:04:00 +08001671 xgl_testing::Image::subresource_range(img_info, XGL_IMAGE_ASPECT_DEPTH);
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001672 std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> ranges(&range, &range + 1);
1673
1674 test_clear_depth_stencil(img_info, 0.25f, 63, ranges);
1675 }
1676}
1677
1678}; // namespace
1679
Chia-I Wud7414b02014-10-21 11:06:26 +08001680int main(int argc, char **argv)
1681{
Chia-I Wud7414b02014-10-21 11:06:26 +08001682 ::testing::InitGoogleTest(&argc, argv);
Chia-I Wud7414b02014-10-21 11:06:26 +08001683
Chia-I Wua9a506a2014-12-27 22:04:00 +08001684 xgl_testing::set_error_callback(test_error_callback);
1685
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001686 environment = new xgl_testing::Environment();
Chia-I Wud7414b02014-10-21 11:06:26 +08001687
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001688 if (!environment->parse_args(argc, argv))
1689 return -1;
Chia-I Wud7414b02014-10-21 11:06:26 +08001690
Chia-I Wu998c2ac2014-12-08 14:30:10 +08001691 ::testing::AddGlobalTestEnvironment(environment);
1692
1693 return RUN_ALL_TESTS();
Chia-I Wud7414b02014-10-21 11:06:26 +08001694}