clfImage3D.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003, 2004    (see file CONTACTS for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Base/Common/BIASpragma.hh>
#include <OpenCLFramework/clfImage3D.hh>
#include <OpenCLFramework/clfException.hh>
#include <Base/Debug/Error.hh>

using namespace BIAS;

std::vector<cl::ImageFormat> clfImage3D::imageFormatsReadable_;
std::vector<cl::ImageFormat> clfImage3D::imageFormatsWritable_;
std::vector<cl::ImageFormat> clfImage3D::imageFormatsReadWrite_;


clfImage3D::clfImage3D(cl::Context *context, cl::CommandQueue *queue) : clfMemory(context, queue) {
  BIASWARN("clfImage3D is untested, use with care");
  width_ = 0;
  height_ = 0;
  depth_ = 0;
  stride_ = 0;
  slideStride_ = 0;
  st_ = BIAS::ImageBase::ST_invalid;
  cm_ = BIAS::ImageBase::CM_invalid;
  if (imageFormatsReadable_.empty()) {
    context_->getSupportedImageFormats(CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE3D, &imageFormatsReadable_);
  }
  if (imageFormatsWritable_.empty()) {
    context_->getSupportedImageFormats(CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE3D, &imageFormatsWritable_);
  }
  if (imageFormatsReadWrite_.empty()) {
    context_->getSupportedImageFormats(CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE3D, &imageFormatsReadWrite_);
  }
}

clfImage3D::~clfImage3D() {
}

void clfImage3D::Allocate(
    BIAS::ImageBase::EStorageType st, BIAS::ImageBase::EColorModel cm,
    unsigned int width, unsigned int height, unsigned int levels, unsigned int stride,
    bool readonly, bool writeonly, const void *hostptr, bool copy) {

  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly, hostptr, copy);
  if (cm == BIAS::ImageBase::CM_RGB) {
    BIASWARN("RGB not supported, interpreting as Grey, width*3");
    cm = BIAS::ImageBase::CM_Grey;
    height = height * 3;
  }
  cl::ImageFormat format = DetermineImageFormat_(st,cm);
  if (!GetFormatSupported_(format, readonly, writeonly)) {
    THROW_CL_EXCEPTION(cl::Error(-100, "requested image format is not supported by device."));
  }
  try {
    if (stride == 0) {
      switch (st) {
        case BIAS::ImageBase::ST_float:
          stride = BIAS::ImageBase::GetChannelcount(cm)*width*sizeof(float);
          break;
        case BIAS::ImageBase::ST_unsignedchar:
          stride = BIAS::ImageBase::GetChannelcount(cm)*width*sizeof(unsigned char);
          break;
        default:
          stride = BIAS::ImageBase::GetChannelcount(cm)*width*sizeof(unsigned char);
          THROW_CL_EXCEPTION(cl::Error(-100, "please provide stride for your data type or extend code for automatic support."));
          break;
      }
    }
    if (initialized_ && !sharedGL_ && stride_ == stride && width == width_ && height == height_) {
      // already allocated with correct size
      return;
    }
    width_ = width;
    height_ = height;
    depth_ = levels;
    stride_ = stride;
    slideStride_ = stride*height;
    size_ = slideStride_*depth_;
    st_ = st;
    cm_ = cm;
    buffer_ = cl::Image3D(*context_, cl_mem_flags, format, width_, height_, depth_, 0, 0, (void*)hostptr);

  } catch(cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
  initialized_ = true;
  sharedGL_ = false;
}

void clfImage3D::AllocateFromBiasTemplate(const BIAS::ImageBase &image, unsigned int levels, bool readonly, bool writeonly) {
  Allocate(
      image.GetStorageType(), image.GetColorModel(),
      image.GetWidth(), image.GetHeight(), levels, 0,
      readonly, writeonly);
}

void clfImage3D::AllocateFromTemplate(const clfImage3D &src, bool readonly, bool writeonly) {
  Allocate(src.st_, src.cm_, src.width_, src.height_, src.depth_, src.stride_, readonly, writeonly);
}

void clfImage3D::AllocateFromTexture3D(BIAS::glfTexture3D &tex, bool readonly, bool writeonly) {
  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly);
  try {
#ifdef CL_VERSION_1_2
    buffer_ = cl::ImageGL(*context_, cl_mem_flags, tex.GetTextureTarget(), 0, tex.GetTextureID());
#else
    buffer_ = cl::Image3DGL(*context_, cl_mem_flags, tex.GetTextureTarget(), 0, tex.GetTextureID());
#endif
    size_t memsize;
    buffer_.getInfo(CL_MEM_SIZE, &memsize);
    size_ = memsize;
  } catch(cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
  initialized_ = true;
  sharedGL_ = true;
}

cl::Image3D& clfImage3D::image() {
  return (cl::Image3D&)buffer_;
}

void clfImage3D::WriteToImage(const void *data,
    unsigned int originX, unsigned int originY, unsigned int originZ,
    unsigned int regionX, unsigned int regionY, unsigned int regionZ)
{
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  if (regionZ == 0) {
    regionZ = depth_;
  }
  cl::size_t<3> origin, region;
  MakeDim_(origin, originX, originY, originZ);
  MakeDim_(region, regionX, regionY, regionZ);

  try {
    queue_->enqueueWriteImage(image(), CL_TRUE, origin, region, 0, 0, (void*)data);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

void clfImage3D::ReadFromImage(void *data,
    unsigned int originX, unsigned int originY, unsigned int originZ,
    unsigned int regionX, unsigned int regionY, unsigned int regionZ)
{
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  if (regionZ == 0) {
    regionZ = depth_;
  }
  cl::size_t<3> origin, region;
  MakeDim_(origin, originX, originY, originZ);
  MakeDim_(region, regionX, regionY, regionZ);
  try {
    queue_->enqueueReadImage(image(), CL_TRUE, origin, region, 0, 0, data);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

void clfImage3D::CopyToImage(clfImage3D &outputimage,
    unsigned int srcoriginX, unsigned int srcoriginY, unsigned int srcoriginZ,
    unsigned int dstoriginX, unsigned int dstoriginY, unsigned int dstoriginZ,
    unsigned int regionX, unsigned int regionY, unsigned int regionZ)
{
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  if (regionZ == 0) {
    regionZ = depth_;
  }
  cl::size_t<3> srcorigin, dstorigin, region;
  MakeDim_(srcorigin, srcoriginX, srcoriginY, srcoriginZ);
  MakeDim_(dstorigin, dstoriginX, dstoriginY, dstoriginZ);
  MakeDim_(region, regionX, regionY, regionZ);
  try {
    cl::Event event;
    queue_->enqueueCopyImage(image(), outputimage.image(), srcorigin, dstorigin, region, NULL, &event);
    event.wait();
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

void* clfImage3D::MapImage(bool write,
    unsigned int originX, unsigned int originY, unsigned int originZ,
    unsigned int regionX, unsigned int regionY, unsigned int regionZ)
{
  try {
    cl_map_flags mapflags = 0;
    if (write) {
      mapflags = CL_MAP_WRITE;
    } else {
      mapflags = CL_MAP_READ;
    }
    if (regionX == 0) {
      regionX = width_;
    }
    if (regionY == 0) {
      regionY = height_;
    }
    if (regionZ == 0) {
      regionZ = depth_;
    }
    cl::size_t<3> origin, region;
    MakeDim_(origin, originX, originY, originZ);
    MakeDim_(region, regionX, regionY, regionZ);
    return queue_->enqueueMapImage(image(), CL_TRUE, mapflags, origin, region, 0, NULL);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
  return NULL;
}

void clfImage3D::CopyToBiasImage(BIAS::ImageBase &image, unsigned int level,
    unsigned int originX, unsigned int originY,
    unsigned int regionX, unsigned int regionY)
{
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  int sx = regionX - originX;
  int sy = regionY - originY;
  if (!image.IsEmpty()) {
    if (sx == (int)image.GetWidth() && sy == (int)image.GetHeight() && cm_ == image.GetColorModel() && st_ == image.GetStorageType()) {
      // is already correctly initialized
    } else {
      image.Release(true);
      image.Init(sx,sy, BIAS::ImageBase::GetChannelcount(cm_), st_);
    }
  } else {
    image.Init(sx,sy, BIAS::ImageBase::GetChannelcount(cm_), st_);
  }
  ReadFromImage( image.GetImageData(), originX, originY, level, sx, sy, level+1 );
}

std::vector<std::string> clfImage3D::GetSupportedImageFormats(bool readonly, bool writeonly) {
  std::vector<cl::ImageFormat> *dat = NULL;
  if (readonly) {
    dat = &clfImage3D::imageFormatsReadable_;
  } else if (writeonly) {
    dat = &clfImage3D::imageFormatsWritable_;
  } else {
    dat = &clfImage3D::imageFormatsReadWrite_;
  }
  std::vector<std::string> result( dat->size() );
  for (unsigned int i=0;i<dat->size();i++) {
    switch ((*dat)[i].image_channel_order) {
      case CL_R:
        result[i] = "one channel (R) \t";
        break;
      case CL_A:
        result[i] = "one channel (A) \t";
        break;
      case CL_INTENSITY:
        result[i] = "one channel (Intensity)\t";
        break;
      case CL_LUMINANCE:
        result[i] = "one channel (Luminance)\t";
        break;
      case CL_RG:
        result[i] = "two channels (RG) \t";
        break;
      case CL_RA:
        result[i] = "two channels (RA) \t";
        break;
      case CL_Rx:
        result[i] = "two channels (Rx) \t";
        break;
      case CL_RGB:
        result[i] = "three channels (RGB) \t";
        break;
      case CL_RGx:
        result[i] = "three channels (RGx) \t";
        break;
      case CL_RGBA:
        result[i] = "four channels (RGBA) \t";
        break;
      case CL_BGRA:
        result[i] = "four channels (BGRA) \t";
        break;
      case CL_ARGB:
        result[i] = "four channels (ARGB) \t";
        break;
      case CL_RGBx:
        result[i] = "four channels (RGBx) \t";
        break;
    };
    switch ((*dat)[i].image_channel_data_type) {
      case CL_SNORM_INT8:
        result[i] += "signed normalized char";
        break;
      case CL_SNORM_INT16:
        result[i] += "signed normalized short";
        break;
      case CL_UNORM_INT8:
        result[i] += "unsigned normalized char";
        break;
      case CL_UNORM_INT16:
        result[i] += "unsigned normalized short";
        break;
      case CL_UNORM_SHORT_565:
        result[i] += "unsigned normalized short 565";
        break;
      case CL_UNORM_SHORT_555:
        result[i] += "unsigned normalized short 555";
        break;
      case CL_UNORM_INT_101010:
        result[i] += "unsigned normalized int 101010";
        break;
      case CL_SIGNED_INT8:
        result[i] += "signed char";
        break;
      case CL_SIGNED_INT16:
        result[i] += "signed short";
        break;
      case CL_SIGNED_INT32:
        result[i] += "signed int";
        break;
      case CL_UNSIGNED_INT8:
        result[i] += "unsigned char";
        break;
      case CL_UNSIGNED_INT16:
        result[i] += "unsigned short";
        break;
      case CL_UNSIGNED_INT32:
        result[i] += "unsigned int";
        break;
      case CL_HALF_FLOAT:
        result[i] += "half float";
        break;
      case CL_FLOAT:
        result[i] += "float";
        break;
    }
  }
  return result;
}

cl::ImageFormat clfImage3D::DetermineImageFormat_(BIAS::ImageBase::EStorageType st, BIAS::ImageBase::EColorModel cm) {
  cl::ImageFormat format;
  switch (st) {
    case BIAS::ImageBase::ST_char:
      format.image_channel_data_type = CL_SIGNED_INT8;
      break;
    case BIAS::ImageBase::ST_unsignedshortint:
      format.image_channel_data_type = CL_UNSIGNED_INT16;
      break;
    case BIAS::ImageBase::ST_shortint:
      format.image_channel_data_type = CL_SIGNED_INT16;
      break;
    case BIAS::ImageBase::ST_unsignedint:
      format.image_channel_data_type = CL_UNSIGNED_INT32;
      break;
    case BIAS::ImageBase::ST_int:
      format.image_channel_data_type = CL_SIGNED_INT32;
      break;
    case BIAS::ImageBase::ST_float:
      format.image_channel_data_type = CL_FLOAT;
      break;
    case BIAS::ImageBase::ST_unsignedchar:
      format.image_channel_data_type = CL_UNSIGNED_INT8;
      break;
    case BIAS::ImageBase::ST_invalid:
    case BIAS::ImageBase::ST_double:
    default:
      THROW_CL_EXCEPTION(cl::Error(-100, "image storage type not supported!"));
      break;
  }

  switch (cm) {
  // one channel
    case BIAS::ImageBase::CM_Grey:
    case BIAS::ImageBase::CM_Bayer_RGGB:
    case BIAS::ImageBase::CM_Bayer_GBRG:
    case BIAS::ImageBase::CM_Bayer_GRBG:
    case BIAS::ImageBase::CM_Bayer_BGGR:
      format.image_channel_order = CL_R;
      break;
    case BIAS::ImageBase::CM_Disparity:
    case BIAS::ImageBase::CM_Depth:
      format.image_channel_order = CL_INTENSITY;
      break;
  // two channel
    case BIAS::ImageBase::CM_GreyA:
    case BIAS::ImageBase::CM_DepthAndVariance:
    case BIAS::ImageBase::CM_YUYV422:
      format.image_channel_order = CL_RA;
      break;
  // three channel
    case BIAS::ImageBase::CM_RGB:
    case BIAS::ImageBase::CM_BGR:
    case BIAS::ImageBase::CM_HSV:
    case BIAS::ImageBase::CM_HSL:
    case BIAS::ImageBase::CM_hsL:
    case BIAS::ImageBase::CM_LUV:
    case BIAS::ImageBase::CM_XYZ:
    case BIAS::ImageBase::CM_LAB:
      format.image_channel_order = CL_RGB;
      break;
  // four channel
    case BIAS::ImageBase::CM_RGBA:
    case BIAS::ImageBase::CM_BGRA:
    case BIAS::ImageBase::CM_RGBE:
      format.image_channel_order = CL_RGBA;
      break;
    default:
      THROW_CL_EXCEPTION(cl::Error(-100, "color model not supported!"));
    break;
  }
  return format;
}

bool clfImage3D::GetFormatSupported_(cl::ImageFormat test, bool readonly, bool writeonly) {
  std::vector<cl::ImageFormat> *dat = NULL;
  if (readonly) {
    dat = &clfImage3D::imageFormatsReadable_;
  } else if (writeonly) {
    dat = &clfImage3D::imageFormatsWritable_;
  } else {
    dat = &clfImage3D::imageFormatsReadWrite_;
  }
  for (unsigned int i=0;i<dat->size();i++) {
    if (test.image_channel_data_type == (*dat)[i].image_channel_data_type) {
      if (test.image_channel_order == (*dat)[i].image_channel_order) {
        return true;
      }
    }
  }
  return false;
}

void clfImage3D::MakeDim_(cl::size_t<3> &dest, int x, int y, int z) {
  dest[0] = x;
  dest[1] = y;
  dest[2] = z;
}