Publishing R3
[platform/upstream/dldt.git] / inference-engine / thirdparty / clDNN / common / boost / 1.64.0 / include / boost-1_64 / boost / compute / image / image_sampler.hpp
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_SAMPLER_HPP
12 #define BOOST_COMPUTE_IMAGE_IMAGE_SAMPLER_HPP
13
14 #include <boost/throw_exception.hpp>
15
16 #include <boost/compute/config.hpp>
17 #include <boost/compute/context.hpp>
18 #include <boost/compute/kernel.hpp>
19 #include <boost/compute/detail/get_object_info.hpp>
20 #include <boost/compute/detail/assert_cl_success.hpp>
21 #include <boost/compute/exception/opencl_error.hpp>
22 #include <boost/compute/type_traits/type_name.hpp>
23
24 namespace boost {
25 namespace compute {
26
27 /// \class image_sampler
28 /// \brief An OpenCL image sampler object
29 ///
30 /// \see image2d, image_format
31 class image_sampler
32 {
33 public:
34     enum addressing_mode {
35         none = CL_ADDRESS_NONE,
36         clamp_to_edge = CL_ADDRESS_CLAMP_TO_EDGE,
37         clamp = CL_ADDRESS_CLAMP,
38         repeat = CL_ADDRESS_REPEAT
39     };
40
41     enum filter_mode {
42         nearest = CL_FILTER_NEAREST,
43         linear = CL_FILTER_LINEAR
44     };
45
46     image_sampler()
47         : m_sampler(0)
48     {
49     }
50
51     image_sampler(const context &context,
52                   bool normalized_coords,
53                   cl_addressing_mode addressing_mode,
54                   cl_filter_mode filter_mode)
55     {
56         cl_int error = 0;
57
58         #ifdef CL_VERSION_2_0
59         std::vector<cl_sampler_properties> sampler_properties;
60         sampler_properties.push_back(CL_SAMPLER_NORMALIZED_COORDS);
61         sampler_properties.push_back(cl_sampler_properties(normalized_coords));
62         sampler_properties.push_back(CL_SAMPLER_ADDRESSING_MODE);
63         sampler_properties.push_back(cl_sampler_properties(addressing_mode));
64         sampler_properties.push_back(CL_SAMPLER_FILTER_MODE);
65         sampler_properties.push_back(cl_sampler_properties(filter_mode));
66         sampler_properties.push_back(cl_sampler_properties(0));
67
68         m_sampler = clCreateSamplerWithProperties(
69             context, &sampler_properties[0], &error
70         );
71         #else
72         m_sampler = clCreateSampler(
73             context, normalized_coords, addressing_mode, filter_mode, &error
74         );
75         #endif
76
77         if(!m_sampler){
78             BOOST_THROW_EXCEPTION(opencl_error(error));
79         }
80     }
81
82     explicit image_sampler(cl_sampler sampler, bool retain = true)
83         : m_sampler(sampler)
84     {
85         if(m_sampler && retain){
86             clRetainSampler(m_sampler);
87         }
88     }
89
90     /// Creates a new image sampler object as a copy of \p other.
91     image_sampler(const image_sampler &other)
92         : m_sampler(other.m_sampler)
93     {
94         if(m_sampler){
95             clRetainSampler(m_sampler);
96         }
97     }
98
99     /// Copies the image sampler object from \p other to \c *this.
100     image_sampler& operator=(const image_sampler &other)
101     {
102         if(this != &other){
103             if(m_sampler){
104                 clReleaseSampler(m_sampler);
105             }
106
107             m_sampler = other.m_sampler;
108
109             if(m_sampler){
110                 clRetainSampler(m_sampler);
111             }
112         }
113
114         return *this;
115     }
116
117     #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES
118     image_sampler(image_sampler&& other) BOOST_NOEXCEPT
119         : m_sampler(other.m_sampler)
120     {
121         other.m_sampler = 0;
122     }
123
124     image_sampler& operator=(image_sampler&& other) BOOST_NOEXCEPT
125     {
126         if(m_sampler){
127             clReleaseSampler(m_sampler);
128         }
129
130         m_sampler = other.m_sampler;
131         other.m_sampler = 0;
132
133         return *this;
134     }
135     #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES
136
137     /// Destroys the image sampler object.
138     ~image_sampler()
139     {
140         if(m_sampler){
141             BOOST_COMPUTE_ASSERT_CL_SUCCESS(
142                 clReleaseSampler(m_sampler)
143             );
144         }
145     }
146
147     /// Returns the underlying \c cl_sampler object.
148     cl_sampler& get() const
149     {
150         return const_cast<cl_sampler &>(m_sampler);
151     }
152
153     /// Returns the context for the image sampler object.
154     context get_context() const
155     {
156         return context(get_info<cl_context>(CL_SAMPLER_CONTEXT));
157     }
158
159     /// Returns information about the sampler.
160     ///
161     /// \see_opencl_ref{clGetSamplerInfo}
162     template<class T>
163     T get_info(cl_sampler_info info) const
164     {
165         return detail::get_object_info<T>(clGetSamplerInfo, m_sampler, info);
166     }
167
168     /// \overload
169     template<int Enum>
170     typename detail::get_object_info_type<image_sampler, Enum>::type
171     get_info() const;
172
173     /// Returns \c true if the sampler is the same at \p other.
174     bool operator==(const image_sampler &other) const
175     {
176         return m_sampler == other.m_sampler;
177     }
178
179     /// Returns \c true if the sampler is different from \p other.
180     bool operator!=(const image_sampler &other) const
181     {
182         return m_sampler != other.m_sampler;
183     }
184
185     operator cl_sampler() const
186     {
187         return m_sampler;
188     }
189
190 private:
191     cl_sampler m_sampler;
192 };
193
194 /// \internal_ define get_info() specializations for image_sampler
195 BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(image_sampler,
196     ((cl_uint, CL_SAMPLER_REFERENCE_COUNT))
197     ((cl_context, CL_SAMPLER_CONTEXT))
198     ((cl_addressing_mode, CL_SAMPLER_ADDRESSING_MODE))
199     ((cl_filter_mode, CL_SAMPLER_FILTER_MODE))
200     ((bool, CL_SAMPLER_NORMALIZED_COORDS))
201 )
202
203 namespace detail {
204
205 // set_kernel_arg specialization for image samplers
206 template<>
207 struct set_kernel_arg<image_sampler>
208 {
209     void operator()(kernel &kernel_, size_t index, const image_sampler &sampler)
210     {
211         kernel_.set_arg(index, sampler.get());
212     }
213 };
214
215 } // end detail namespace
216 } // end compute namespace
217 } // end boost namespace
218
219 BOOST_COMPUTE_TYPE_NAME(boost::compute::image_sampler, sampler_t)
220
221 #endif // BOOST_COMPUTE_IMAGE_IMAGE_SAMPLER_HPP