]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | //---------------------------------------------------------------------------// |
2 | // Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> | |
3 | // | |
4 | // Distributed under the Boost Software License, Version 1.0 | |
5 | // See accompanying file LICENSE_1_0.txt or copy at | |
6 | // http://www.boost.org/LICENSE_1_0.txt | |
7 | // | |
8 | // See http://boostorg.github.com/compute for more information. | |
9 | //---------------------------------------------------------------------------// | |
10 | ||
11 | #define BOOST_TEST_MODULE TestImage2D | |
12 | #include <boost/test/unit_test.hpp> | |
13 | ||
14 | #include <iostream> | |
15 | ||
16 | #include <boost/compute/system.hpp> | |
17 | #include <boost/compute/image/image2d.hpp> | |
18 | #include <boost/compute/utility/dim.hpp> | |
19 | ||
20 | #include "quirks.hpp" | |
21 | #include "context_setup.hpp" | |
22 | ||
23 | namespace compute = boost::compute; | |
24 | ||
25 | BOOST_AUTO_TEST_CASE(image2d_get_supported_formats) | |
26 | { | |
27 | const std::vector<compute::image_format> formats = | |
28 | compute::image2d::get_supported_formats(context); | |
29 | } | |
30 | ||
31 | BOOST_AUTO_TEST_CASE(create_image_doctest) | |
32 | { | |
33 | try { | |
34 | //! [create_image] | |
35 | // create 8-bit RGBA image format | |
36 | boost::compute::image_format rgba8(CL_RGBA, CL_UNSIGNED_INT8); | |
37 | ||
38 | // create 640x480 image object | |
39 | boost::compute::image2d img(context, 640, 480, rgba8); | |
40 | //! [create_image] | |
41 | ||
42 | // verify image has been created and format is correct | |
43 | BOOST_CHECK(img.get() != cl_mem()); | |
44 | BOOST_CHECK(img.format() == rgba8); | |
45 | BOOST_CHECK_EQUAL(img.width(), size_t(640)); | |
46 | BOOST_CHECK_EQUAL(img.height(), size_t(480)); | |
47 | } | |
48 | catch(compute::opencl_error &e){ | |
49 | if(e.error_code() == CL_IMAGE_FORMAT_NOT_SUPPORTED){ | |
50 | // image format not supported by device | |
51 | return; | |
52 | } | |
53 | ||
54 | // some other error, rethrow | |
55 | throw; | |
56 | } | |
57 | } | |
58 | ||
59 | BOOST_AUTO_TEST_CASE(get_info) | |
60 | { | |
61 | compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8); | |
62 | ||
63 | if(!compute::image2d::is_supported_format(format, context)){ | |
64 | std::cerr << "skipping get_info test, image format not supported" << std::endl; | |
65 | return; | |
66 | } | |
67 | ||
68 | compute::image2d image( | |
69 | context, 48, 64, format, compute::image2d::read_only | |
70 | ); | |
71 | ||
72 | BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_WIDTH), size_t(48)); | |
73 | BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_HEIGHT), size_t(64)); | |
74 | BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_DEPTH), size_t(0)); | |
75 | BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_ROW_PITCH), size_t(48*4)); | |
76 | BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_SLICE_PITCH), size_t(0)); | |
77 | BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_ELEMENT_SIZE), size_t(4)); | |
78 | ||
79 | BOOST_CHECK(image.format() == format); | |
80 | BOOST_CHECK_EQUAL(image.width(), size_t(48)); | |
81 | BOOST_CHECK_EQUAL(image.height(), size_t(64)); | |
82 | } | |
83 | ||
84 | BOOST_AUTO_TEST_CASE(clone_image) | |
85 | { | |
86 | compute::image_format format(CL_RGBA, CL_UNORM_INT8); | |
87 | ||
88 | if(!compute::image2d::is_supported_format(format, context)){ | |
89 | std::cerr << "skipping clone_image test, image format not supported" << std::endl; | |
90 | return; | |
91 | } | |
92 | ||
93 | // image data | |
94 | unsigned int data[] = { 0x0000ffff, 0xff00ffff, | |
95 | 0x00ff00ff, 0xffffffff }; | |
96 | ||
97 | // create image on the device | |
98 | compute::image2d image(context, 2, 2, format); | |
99 | ||
100 | // ensure we have a valid image object | |
101 | BOOST_REQUIRE(image.get() != cl_mem()); | |
102 | ||
103 | // copy image data to the device | |
104 | queue.enqueue_write_image(image, image.origin(), image.size(), data); | |
105 | ||
106 | // clone image | |
107 | compute::image2d copy = image.clone(queue); | |
108 | ||
109 | // ensure image format is the same | |
110 | BOOST_CHECK(copy.format() == image.format()); | |
111 | ||
112 | // read cloned image data back to the host | |
113 | unsigned int cloned_data[4]; | |
114 | queue.enqueue_read_image(copy, image.origin(), image.size(), cloned_data); | |
115 | ||
116 | // ensure original data and cloned data are the same | |
117 | BOOST_CHECK_EQUAL(cloned_data[0], data[0]); | |
118 | BOOST_CHECK_EQUAL(cloned_data[1], data[1]); | |
119 | BOOST_CHECK_EQUAL(cloned_data[2], data[2]); | |
120 | BOOST_CHECK_EQUAL(cloned_data[3], data[3]); | |
121 | } | |
122 | ||
b32b8144 | 123 | #ifdef BOOST_COMPUTE_CL_VERSION_1_2 |
7c673cae FG |
124 | BOOST_AUTO_TEST_CASE(fill_image) |
125 | { | |
126 | REQUIRES_OPENCL_VERSION(1, 2); // device OpenCL version check | |
127 | ||
128 | compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8); | |
129 | ||
130 | if(!compute::image2d::is_supported_format(format, context)){ | |
131 | std::cerr << "skipping fill_image test, image format not supported" << std::endl; | |
132 | return; | |
133 | } | |
134 | ||
135 | compute::image2d img(context, 640, 480, format); | |
136 | ||
137 | // fill image with black | |
138 | compute::uint4_ black(0, 0, 0, 255); | |
139 | queue.enqueue_fill_image(img, &black, img.origin(), img.size()); | |
140 | ||
141 | // read value of first pixel | |
142 | compute::uchar4_ first_pixel; | |
143 | queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel); | |
144 | BOOST_CHECK_EQUAL(first_pixel, compute::uchar4_(0, 0, 0, 255)); | |
145 | ||
146 | // fill image with white | |
147 | compute::uint4_ white(255, 255, 255, 255); | |
148 | queue.enqueue_fill_image(img, &white, img.origin(), img.size()); | |
149 | ||
150 | // read value of first pixel | |
151 | queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel); | |
152 | BOOST_CHECK_EQUAL(first_pixel, compute::uchar4_(255, 255, 255, 255)); | |
153 | } | |
154 | #endif | |
155 | ||
156 | // check type_name() for image2d | |
157 | BOOST_AUTO_TEST_CASE(image2d_type_name) | |
158 | { | |
159 | BOOST_CHECK( | |
160 | std::strcmp( | |
161 | boost::compute::type_name<boost::compute::image2d>(), "image2d_t" | |
162 | ) == 0 | |
163 | ); | |
164 | } | |
165 | ||
166 | BOOST_AUTO_TEST_CASE(map_image) | |
167 | { | |
168 | compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8); | |
169 | ||
170 | if(!compute::image2d::is_supported_format(format, context)){ | |
171 | std::cerr << "skipping clone_image test, image format not supported" << std::endl; | |
172 | return; | |
173 | } | |
174 | ||
175 | // create image on the device | |
176 | compute::image2d image(context, 2, 2, format); | |
177 | ||
178 | // ensure we have a valid image object | |
179 | BOOST_REQUIRE(image.get() != cl_mem()); | |
180 | ||
181 | size_t row_pitch = 0; | |
182 | size_t slice_pitch = 0; | |
183 | ||
184 | // write map image | |
185 | compute::uint_* ptr = static_cast<compute::uint_*>( | |
186 | queue.enqueue_map_image(image, CL_MAP_WRITE, image.origin(), | |
187 | image.size(), row_pitch, slice_pitch) | |
188 | ); | |
189 | ||
190 | BOOST_CHECK_EQUAL(row_pitch, size_t(2*4)); | |
191 | ||
192 | // image data | |
193 | compute::uint_ data[] = { 0x0000ffff, 0xff00ffff, | |
194 | 0x00ff00ff, 0xffffffff }; | |
195 | ||
196 | // copy data to image | |
197 | for(size_t i = 0; i < 4; i++){ | |
198 | *(ptr+i) = data[i]; | |
199 | } | |
200 | ||
201 | // unmap | |
202 | queue.enqueue_unmap_image(image, static_cast<void*>(ptr)); | |
203 | ||
204 | // read map image | |
205 | compute::event map_event; | |
206 | ptr = static_cast<compute::uint_*>( | |
207 | queue.enqueue_map_image_async(image, CL_MAP_READ, image.origin(), | |
208 | image.size(), row_pitch, slice_pitch, | |
209 | map_event) | |
210 | ); | |
211 | ||
212 | map_event.wait(); | |
213 | ||
214 | BOOST_CHECK(map_event.get_status() == CL_COMPLETE); | |
215 | BOOST_CHECK_EQUAL(row_pitch, size_t(2*4)); | |
216 | ||
217 | // checking | |
218 | for(size_t i = 0; i < 4; i++){ | |
219 | BOOST_CHECK_EQUAL(*(ptr+i), data[i]); | |
220 | } | |
221 | ||
222 | // unmap | |
223 | queue.enqueue_unmap_image(image, static_cast<void*>(ptr)); | |
224 | } | |
225 | ||
226 | BOOST_AUTO_TEST_SUITE_END() |