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: image_object()35 image_object() 36 : memory_object() 37 { 38 } 39 image_object(cl_mem mem,bool retain=true)40 explicit image_object(cl_mem mem, bool retain = true) 41 : memory_object(mem, retain) 42 { 43 } 44 image_object(const image_object & other)45 image_object(const image_object &other) 46 : memory_object(other) 47 { 48 } 49 operator =(const image_object & other)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 image_object(image_object && other)60 image_object(image_object&& other) BOOST_NOEXCEPT 61 : memory_object(std::move(other)) 62 { 63 } 64 65 /// \internal_ operator =(image_object && other)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. ~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> get_image_info(cl_mem_info info) const83 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. format() const89 image_format format() const 90 { 91 return image_format(get_image_info<cl_image_format>(CL_IMAGE_FORMAT)); 92 } 93 94 /// \internal_ (deprecated) get_format() const95 image_format get_format() const 96 { 97 return format(); 98 } 99 100 /// Returns the width of the image. width() const101 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. height() const109 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. depth() const117 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> get_supported_formats(const context & context,cl_mem_object_type type,cl_mem_flags flags=read_write)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. is_supported_format(const image_format & format,const context & context,cl_mem_object_type type,cl_mem_flags flags=read_write)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 171