ceph/src/boost/libs/compute/example/resize_image.cpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2013-2014 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 #include <iostream>
  12 #include <algorithm>
  13
  14 #include <QtGlobal>
  15 #if QT_VERSION >= 0x050000
  16 #include <QtWidgets>
  17 #else
  18 #include <QtGui>
  19 #endif
  20 #include <QtOpenGL>
  21
  22 #include <boost/program_options.hpp>
  23
  24 #ifndef Q_MOC_RUN
  25 #include <boost/compute/command_queue.hpp>
  26 #include <boost/compute/kernel.hpp>
  27 #include <boost/compute/program.hpp>
  28 #include <boost/compute/system.hpp>
  29 #include <boost/compute/image/image2d.hpp>
  30 #include <boost/compute/image/image_sampler.hpp>
  31 #include <boost/compute/interop/qt.hpp>
  32 #include <boost/compute/interop/opengl.hpp>
  33 #include <boost/compute/utility/source.hpp>
  34 #endif // Q_MOC_RUN
  35
  36 namespace compute = boost::compute;
  37 namespace po = boost::program_options;
  38
  39 // opencl source code
  40 const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE(
  41     __kernel void resize_image(__read_only image2d_t input,
  42                                const sampler_t sampler,
  43                                __write_only image2d_t output)
  44     {
  45         const uint x = get_global_id(0);
  46         const uint y = get_global_id(1);
  47
  48         const float w = get_image_width(output);
  49         const float h = get_image_height(output);
  50
  51         float2 coord = { ((float) x / w) * get_image_width(input),
  52                          ((float) y / h) * get_image_height(input) };
  53
  54         float4 pixel = read_imagef(input, sampler, coord);
  55         write_imagef(output, (int2)(x, h - y - 1), pixel);
  56     };
  57 );
  58
  59 class ImageWidget : public QGLWidget
  60 {
  61     Q_OBJECT
  62
  63 public:
  64     ImageWidget(QString fileName, QWidget *parent = 0);
  65     ~ImageWidget();
  66
  67     void initializeGL();
  68     void resizeGL(int width, int height);
  69     void paintGL();
  70
  71 private:
  72     QImage qt_image_;
  73     compute::context context_;
  74     compute::command_queue queue_;
  75     compute::program program_;
  76     compute::image2d image_;
  77     compute::image_sampler sampler_;
  78     GLuint gl_texture_;
  79     compute::opengl_texture cl_texture_;
  80 };
  81
  82 ImageWidget::ImageWidget(QString fileName, QWidget *parent)
  83     : QGLWidget(parent),
  84       qt_image_(fileName)
  85 {
  86     gl_texture_ = 0;
  87 }
  88
  89 ImageWidget::~ImageWidget()
  90 {
  91 }
  92
  93 void ImageWidget::initializeGL()
  94 {
  95     // setup opengl
  96     glDisable(GL_LIGHTING);
  97
  98     // create the OpenGL/OpenCL shared context
  99     context_ = compute::opengl_create_shared_context();
 100
 101     // get gpu device
 102     compute::device gpu = context_.get_device();
 103     std::cout << "device: " << gpu.name() << std::endl;
 104
 105     // setup command queue
 106     queue_ = compute::command_queue(context_, gpu);
 107
 108     // allocate image on the device
 109     compute::image_format format =
 110         compute::qt_qimage_format_to_image_format(qt_image_.format());
 111
 112     image_ = compute::image2d(
 113         context_, qt_image_.width(), qt_image_.height(), format, CL_MEM_READ_ONLY
 114     );
 115
 116     // transfer image to the device
 117     compute::qt_copy_qimage_to_image2d(qt_image_, image_, queue_);
 118
 119     // setup image sampler (use CL_FILTER_NEAREST to disable linear interpolation)
 120     sampler_ = compute::image_sampler(
 121         context_, false, CL_ADDRESS_NONE, CL_FILTER_LINEAR
 122     );
 123
 124     // build resize program
 125     program_ = compute::program::build_with_source(source, context_);
 126 }
 127
 128 void ImageWidget::resizeGL(int width, int height)
 129 {
 130 #if QT_VERSION >= 0x050000
 131     // scale height/width based on device pixel ratio
 132     width /= windowHandle()->devicePixelRatio();
 133     height /= windowHandle()->devicePixelRatio();
 134 #endif
 135
 136     // resize viewport
 137     glViewport(0, 0, width, height);
 138
 139     // delete old texture
 140     if(gl_texture_){
 141       glDeleteTextures(1, &gl_texture_);
 142       gl_texture_ = 0;
 143     }
 144
 145     // generate new texture
 146     glGenTextures(1, &gl_texture_);
 147     glBindTexture(GL_TEXTURE_2D, gl_texture_);
 148     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 149     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 150     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 151     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 152     glTexImage2D(
 153         GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0
 154     );
 155
 156     // create opencl object for the texture
 157     cl_texture_ = compute::opengl_texture(
 158         context_, GL_TEXTURE_2D, 0, gl_texture_, CL_MEM_WRITE_ONLY
 159     );
 160 }
 161
 162 void ImageWidget::paintGL()
 163 {
 164     float w = width();
 165     float h = height();
 166
 167     glMatrixMode(GL_PROJECTION);
 168     glLoadIdentity();
 169     glOrtho(0.0, w, 0.0, h, -1.0, 1.0);
 170     glMatrixMode(GL_MODELVIEW);
 171     glLoadIdentity();
 172
 173     // setup the resize kernel
 174     compute::kernel kernel(program_, "resize_image");
 175     kernel.set_arg(0, image_);
 176     kernel.set_arg(1, sampler_);
 177     kernel.set_arg(2, cl_texture_);
 178
 179     // acquire the opengl texture so it can be used in opencl
 180     compute::opengl_enqueue_acquire_gl_objects(1, &cl_texture_.get(), queue_);
 181
 182     // execute the resize kernel
 183     const size_t global_work_offset[] = { 0, 0 };
 184     const size_t global_work_size[] = { size_t(width()), size_t(height()) };
 185
 186     queue_.enqueue_nd_range_kernel(
 187         kernel, 2, global_work_offset, global_work_size, 0
 188     );
 189
 190     // release the opengl texture so it can be used by opengl
 191     compute::opengl_enqueue_release_gl_objects(1, &cl_texture_.get(), queue_);
 192
 193     // ensure opencl is finished before rendering in opengl
 194     queue_.finish();
 195
 196     // draw a single quad with the resized image texture
 197     glEnable(GL_TEXTURE_2D);
 198     glBindTexture(GL_TEXTURE_2D, gl_texture_);
 199
 200     glBegin(GL_QUADS);
 201     glTexCoord2f(0, 0); glVertex2f(0, 0);
 202     glTexCoord2f(0, 1); glVertex2f(0, h);
 203     glTexCoord2f(1, 1); glVertex2f(w, h);
 204     glTexCoord2f(1, 0); glVertex2f(w, 0);
 205     glEnd();
 206 }
 207
 208 // the resize image example demonstrates how to interactively resize a
 209 // 2D image and display it using OpenGL. a image sampler is used to perform
 210 // hardware-accelerated linear interpolation for the resized image.
 211 int main(int argc, char *argv[])
 212 {
 213     // setup command line arguments
 214     po::options_description options("options");
 215     options.add_options()
 216         ("help", "show usage instructions")
 217         ("file", po::value<std::string>(), "image file name (e.g. /path/to/image.png)")
 218     ;
 219     po::positional_options_description positional_options;
 220     positional_options.add("file", 1);
 221
 222     // parse command line
 223     po::variables_map vm;
 224     po::store(
 225         po::command_line_parser(argc, argv)
 226             .options(options)
 227             .positional(positional_options)
 228             .run(),
 229         vm
 230     );
 231     po::notify(vm);
 232
 233     // check for file argument
 234     if(vm.count("help") || !vm.count("file")){
 235         std::cout << options << std::endl;
 236         return -1;
 237     }
 238
 239     // get file name
 240     std::string file_name = vm["file"].as<std::string>();
 241
 242     // setup qt application
 243     QApplication app(argc, argv);
 244
 245     // setup image widget
 246     ImageWidget widget(QString::fromStdString(file_name));
 247     widget.show();
 248
 249     // run qt application
 250     return app.exec();
 251 }
 252
 253 #include "resize_image.moc"