]>
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 | #ifndef BOOST_COMPUTE_IMAGE_IMAGE_OBJECT_HPP | |
12 | #define BOOST_COMPUTE_IMAGE_IMAGE_OBJECT_HPP | |
13 | ||
14 | #include <algorithm> | |
15 | #include <vector> | |
16 | ||
17 | #include <boost/compute/config.hpp> | |
18 | #include <boost/compute/memory_object.hpp> | |
19 | #include <boost/compute/detail/get_object_info.hpp> | |
20 | #include <boost/compute/image/image_format.hpp> | |
21 | ||
22 | namespace boost { | |
23 | namespace compute { | |
24 | ||
25 | /// \class image_object | |
26 | /// \brief Base-class for image objects. | |
27 | /// | |
28 | /// The image_object class is the base-class for image objects on compute | |
29 | /// devices. | |
30 | /// | |
31 | /// \see image1d, image2d, image3d | |
32 | class image_object : public memory_object | |
33 | { | |
34 | public: | |
35 | image_object() | |
36 | : memory_object() | |
37 | { | |
38 | } | |
39 | ||
40 | explicit image_object(cl_mem mem, bool retain = true) | |
41 | : memory_object(mem, retain) | |
42 | { | |
43 | } | |
44 | ||
45 | image_object(const image_object &other) | |
46 | : memory_object(other) | |
47 | { | |
48 | } | |
49 | ||
50 | image_object& operator=(const image_object &other) | |
51 | { | |
52 | if(this != &other){ | |
53 | memory_object::operator=(other); | |
54 | } | |
55 | ||
56 | return *this; | |
57 | } | |
58 | ||
59 | #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES | |
60 | image_object(image_object&& other) BOOST_NOEXCEPT | |
61 | : memory_object(std::move(other)) | |
62 | { | |
63 | } | |
64 | ||
65 | /// \internal_ | |
66 | image_object& operator=(image_object&& other) BOOST_NOEXCEPT | |
67 | { | |
68 | memory_object::operator=(std::move(other)); | |
69 | ||
70 | return *this; | |
71 | } | |
72 | #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES | |
73 | ||
74 | /// Destroys the image object. | |
75 | ~image_object() | |
76 | { | |
77 | } | |
78 | ||
79 | /// Returns information about the image object. | |
80 | /// | |
81 | /// \see_opencl_ref{clGetImageInfo} | |
82 | template<class T> | |
83 | T get_image_info(cl_mem_info info) const | |
84 | { | |
85 | return detail::get_object_info<T>(clGetImageInfo, m_mem, info); | |
86 | } | |
87 | ||
88 | /// Returns the format for the image. | |
89 | image_format format() const | |
90 | { | |
91 | return image_format(get_image_info<cl_image_format>(CL_IMAGE_FORMAT)); | |
92 | } | |
93 | ||
94 | /// \internal_ (deprecated) | |
95 | image_format get_format() const | |
96 | { | |
97 | return format(); | |
98 | } | |
99 | ||
100 | /// Returns the width of the image. | |
101 | size_t width() const | |
102 | { | |
103 | return get_image_info<size_t>(CL_IMAGE_WIDTH); | |
104 | } | |
105 | ||
106 | /// Returns the height of the image. | |
107 | /// | |
108 | /// For 1D images, this function will return \c 1. | |
109 | size_t height() const | |
110 | { | |
111 | return get_image_info<size_t>(CL_IMAGE_HEIGHT); | |
112 | } | |
113 | ||
114 | /// Returns the depth of the image. | |
115 | /// | |
116 | /// For 1D and 2D images, this function will return \c 1. | |
117 | size_t depth() const | |
118 | { | |
119 | return get_image_info<size_t>(CL_IMAGE_DEPTH); | |
120 | } | |
121 | ||
122 | /// Returns the supported image formats for the \p type in \p context. | |
123 | /// | |
124 | /// \see_opencl_ref{clGetSupportedImageFormats} | |
125 | static std::vector<image_format> | |
126 | get_supported_formats(const context &context, | |
127 | cl_mem_object_type type, | |
128 | cl_mem_flags flags = read_write) | |
129 | { | |
130 | cl_uint count = 0; | |
131 | clGetSupportedImageFormats(context, flags, type, 0, 0, &count); | |
132 | ||
133 | std::vector<cl_image_format> cl_formats(count); | |
134 | clGetSupportedImageFormats(context, flags, type, count, &cl_formats[0], 0); | |
135 | ||
136 | std::vector<image_format> formats; | |
137 | formats.reserve(count); | |
138 | ||
139 | for(cl_uint i = 0; i < count; i++){ | |
140 | formats.push_back(image_format(cl_formats[i])); | |
141 | } | |
142 | ||
143 | return formats; | |
144 | } | |
145 | ||
146 | /// Returns \c true if \p format is a supported image format for | |
147 | /// \p type in \p context with \p flags. | |
148 | static bool is_supported_format(const image_format &format, | |
149 | const context &context, | |
150 | cl_mem_object_type type, | |
151 | cl_mem_flags flags = read_write) | |
152 | { | |
153 | const std::vector<image_format> formats = | |
154 | get_supported_formats(context, type, flags); | |
155 | ||
156 | return std::find(formats.begin(), formats.end(), format) != formats.end(); | |
157 | } | |
158 | }; | |
159 | ||
160 | namespace detail { | |
161 | ||
162 | // set_kernel_arg() specialization for image_object | |
163 | template<> | |
164 | struct set_kernel_arg<image_object> : public set_kernel_arg<memory_object> { }; | |
165 | ||
166 | } // end detail namespace | |
167 | } // end compute namespace | |
168 | } // end boost namespace | |
169 | ||
170 | #endif // BOOST_COMPUTE_IMAGE_IMAGE_OBJECT_HPP |