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