ceph/src/boost/libs/compute/include/boost/compute/image/image2d.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_IMAGE2D_HPP
  12 #define BOOST_COMPUTE_IMAGE_IMAGE2D_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/exception/opencl_error.hpp>
  19 #include <boost/compute/image/image_format.hpp>
  20 #include <boost/compute/image/image_object.hpp>
  21 #include <boost/compute/detail/get_object_info.hpp>
  22 #include <boost/compute/type_traits/type_name.hpp>
  23 #include <boost/compute/utility/extents.hpp>
  24
  25 namespace boost {
  26 namespace compute {
  27
  28 // forward declarations
  29 class command_queue;
  30
  31 /// \class image2d
  32 /// \brief An OpenCL 2D image object
  33 ///
  34 /// For example, to create a 640x480 8-bit RGBA image:
  35 ///
  36 /// \snippet test/test_image2d.cpp create_image
  37 ///
  38 /// \see image_format, image3d
  39 class image2d : public image_object
  40 {
  41 public:
  42     /// Creates a null image2d object.
  43     image2d()
  44         : image_object()
  45     {
  46     }
  47
  48     /// Creates a new image2d object.
  49     ///
  50     /// \see_opencl_ref{clCreateImage}
  51     image2d(const context &context,
  52             size_t image_width,
  53             size_t image_height,
  54             const image_format &format,
  55             cl_mem_flags flags = read_write,
  56             void *host_ptr = 0,
  57             size_t image_row_pitch = 0)
  58     {
  59         cl_int error = 0;
  60
  61         #ifdef CL_VERSION_1_2
  62         cl_image_desc desc;
  63         desc.image_type = CL_MEM_OBJECT_IMAGE2D;
  64         desc.image_width = image_width;
  65         desc.image_height = image_height;
  66         desc.image_depth = 1;
  67         desc.image_array_size = 0;
  68         desc.image_row_pitch = image_row_pitch;
  69         desc.image_slice_pitch = 0;
  70         desc.num_mip_levels = 0;
  71         desc.num_samples = 0;
  72         #ifdef CL_VERSION_2_0
  73         desc.mem_object = 0;
  74         #else
  75         desc.buffer = 0;
  76         #endif
  77
  78         m_mem = clCreateImage(context,
  79                               flags,
  80                               format.get_format_ptr(),
  81                               &desc,
  82                               host_ptr,
  83                               &error);
  84         #else
  85         m_mem = clCreateImage2D(context,
  86                                 flags,
  87                                 format.get_format_ptr(),
  88                                 image_width,
  89                                 image_height,
  90                                 image_row_pitch,
  91                                 host_ptr,
  92                                 &error);
  93         #endif
  94
  95         if(!m_mem){
  96             BOOST_THROW_EXCEPTION(opencl_error(error));
  97         }
  98     }
  99
 100     /// \internal_ (deprecated)
 101     image2d(const context &context,
 102             cl_mem_flags flags,
 103             const image_format &format,
 104             size_t image_width,
 105             size_t image_height,
 106             size_t image_row_pitch = 0,
 107             void *host_ptr = 0)
 108     {
 109         cl_int error = 0;
 110
 111         #ifdef CL_VERSION_1_2
 112         cl_image_desc desc;
 113         desc.image_type = CL_MEM_OBJECT_IMAGE2D;
 114         desc.image_width = image_width;
 115         desc.image_height = image_height;
 116         desc.image_depth = 1;
 117         desc.image_array_size = 0;
 118         desc.image_row_pitch = image_row_pitch;
 119         desc.image_slice_pitch = 0;
 120         desc.num_mip_levels = 0;
 121         desc.num_samples = 0;
 122         #ifdef CL_VERSION_2_0
 123         desc.mem_object = 0;
 124         #else
 125         desc.buffer = 0;
 126         #endif
 127
 128         m_mem = clCreateImage(context,
 129                               flags,
 130                               format.get_format_ptr(),
 131                               &desc,
 132                               host_ptr,
 133                               &error);
 134         #else
 135         m_mem = clCreateImage2D(context,
 136                                 flags,
 137                                 format.get_format_ptr(),
 138                                 image_width,
 139                                 image_height,
 140                                 image_row_pitch,
 141                                 host_ptr,
 142                                 &error);
 143         #endif
 144
 145         if(!m_mem){
 146             BOOST_THROW_EXCEPTION(opencl_error(error));
 147         }
 148     }
 149
 150     /// Creates a new image2d as a copy of \p other.
 151     image2d(const image2d &other)
 152       : image_object(other)
 153     {
 154     }
 155
 156     /// Copies the image2d from \p other.
 157     image2d& operator=(const image2d &other)
 158     {
 159         image_object::operator=(other);
 160
 161         return *this;
 162     }
 163
 164     #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES
 165     /// Move-constructs a new image object from \p other.
 166     image2d(image2d&& other) BOOST_NOEXCEPT
 167         : image_object(std::move(other))
 168     {
 169     }
 170
 171     /// Move-assigns the image from \p other to \c *this.
 172     image2d& operator=(image2d&& other) BOOST_NOEXCEPT
 173     {
 174         image_object::operator=(std::move(other));
 175
 176         return *this;
 177     }
 178     #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES
 179
 180     /// Destroys the image2d object.
 181     ~image2d()
 182     {
 183     }
 184
 185     /// Returns the size (width, height) of the image.
 186     extents<2> size() const
 187     {
 188         extents<2> size;
 189         size[0] = get_info<size_t>(CL_IMAGE_WIDTH);
 190         size[1] = get_info<size_t>(CL_IMAGE_HEIGHT);
 191         return size;
 192     }
 193
 194     /// Returns the origin of the image (\c 0, \c 0).
 195     extents<2> origin() const
 196     {
 197         return extents<2>();
 198     }
 199
 200     /// Returns information about the image.
 201     ///
 202     /// \see_opencl_ref{clGetImageInfo}
 203     template<class T>
 204     T get_info(cl_image_info info) const
 205     {
 206         return detail::get_object_info<T>(clGetImageInfo, m_mem, info);
 207     }
 208
 209     /// \overload
 210     template<int Enum>
 211     typename detail::get_object_info_type<image2d, Enum>::type
 212     get_info() const;
 213
 214     /// Returns the supported image formats for the context.
 215     ///
 216     /// \see_opencl_ref{clGetSupportedImageFormats}
 217     static std::vector<image_format>
 218     get_supported_formats(const context &context, cl_mem_flags flags = read_write)
 219     {
 220         return image_object::get_supported_formats(context, CL_MEM_OBJECT_IMAGE2D, flags);
 221     }
 222
 223     /// Returns \c true if \p format is a supported 2D image format for
 224     /// \p context.
 225     static bool is_supported_format(const image_format &format,
 226                                     const context &context,
 227                                     cl_mem_flags flags = read_write)
 228     {
 229         return image_object::is_supported_format(
 230             format, context, CL_MEM_OBJECT_IMAGE2D, flags
 231         );
 232     }
 233
 234     /// Creates a new image with a copy of the data in \c *this. Uses \p queue
 235     /// to perform the copy operation.
 236     image2d clone(command_queue &queue) const;
 237 };
 238
 239 /// \internal_ define get_info() specializations for image2d
 240 BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(image2d,
 241     ((cl_image_format, CL_IMAGE_FORMAT))
 242     ((size_t, CL_IMAGE_ELEMENT_SIZE))
 243     ((size_t, CL_IMAGE_ROW_PITCH))
 244     ((size_t, CL_IMAGE_SLICE_PITCH))
 245     ((size_t, CL_IMAGE_WIDTH))
 246     ((size_t, CL_IMAGE_HEIGHT))
 247     ((size_t, CL_IMAGE_DEPTH))
 248 )
 249
 250 namespace detail {
 251
 252 // set_kernel_arg() specialization for image2d
 253 template<>
 254 struct set_kernel_arg<image2d> : public set_kernel_arg<image_object> { };
 255
 256 } // end detail namespace
 257 } // end compute namespace
 258 } // end boost namespace
 259
 260 BOOST_COMPUTE_TYPE_NAME(boost::compute::image2d, image2d_t)
 261
 262 #endif // BOOST_COMPUTE_IMAGE_IMAGE2D_HPP