clfImage2D.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/clfImage2D.hh>
#include <OpenCLFramework/clfException.hh>
#include <Base/Debug/Error.hh>

using namespace BIAS;

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


clfImage2D::clfImage2D(cl::Context *context, cl::CommandQueue *queue) : clfMemory(context, queue) {
  width_ = 0;
  height_ = 0;
  stride_ = 0;
  bitdepth_ = 8;
  st_ = BIAS::ImageBase::ST_invalid;
  cm_ = BIAS::ImageBase::CM_invalid;
  tex_ = NULL;
  isSpare_ = false;
  isInUse_ = false;

  if (imageFormatsReadable_.empty()) {
    context_->getSupportedImageFormats(CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE2D, &imageFormatsReadable_);
  }
  if (imageFormatsWritable_.empty()) {
    context_->getSupportedImageFormats(CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE2D, &imageFormatsWritable_);
  }
  if (imageFormatsReadWrite_.empty()) {
    context_->getSupportedImageFormats(CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D, &imageFormatsReadWrite_);
  }
}

clfImage2D::~clfImage2D() {
}

void clfImage2D::Allocate( 
    BIAS::ImageBase::EStorageType st, BIAS::ImageBase::EColorModel cm, 
    unsigned int width, unsigned int height, unsigned int stride,
    bool readonly, bool writeonly, const void *hostptr, bool copy) {
  
  st_ = st;
  cm_ = cm;

  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly, hostptr, copy);
  if (cm == BIAS::ImageBase::CM_RGB) {
    //    if (!initialized_) {
    //      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;
        case BIAS::ImageBase::ST_unsignedshortint:
          stride = BIAS::ImageBase::GetChannelcount(cm)*width*sizeof(unsigned short);
          break;
        case BIAS::ImageBase::ST_int:
          stride = BIAS::ImageBase::GetChannelcount(cm)*width*sizeof(int);
          break;
      case BIAS::ImageBase::ST_unsignedint:
        stride = BIAS::ImageBase::GetChannelcount(cm)*width*sizeof(unsigned int);
        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;
    stride_ = stride;
    size_ = stride*height;
    buffer_ = cl::Image2D(*context_, cl_mem_flags, format, width_, height_, 0, (void*)hostptr);

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

void clfImage2D::AllocateFromBiasImage(const BIAS::ImageBase &image, bool readonly, bool writeonly, bool copy) {
  Allocate(
      image.GetStorageType(), image.GetColorModel(), 
      image.GetWidth(), image.GetHeight(), image.GetWidthStep(),
      readonly, writeonly,
      image.GetImageData(), copy);
  bitdepth_ = image.GetBitDepth();
  SetMetaData(*image.GetMetaData());
}

void clfImage2D::AllocateFromBiasTemplate(const BIAS::ImageBase &image, bool readonly, bool writeonly) {
  Allocate(
      image.GetStorageType(), image.GetColorModel(), 
      image.GetWidth(), image.GetHeight(), image.GetWidthStep(),
      readonly, writeonly);
  bitdepth_ = image.GetBitDepth();
  SetMetaData(*image.GetMetaData());
}

void clfImage2D::AllocateFromTemplate(const clfImage2D &src, bool readonly, bool writeonly) {
  if (src.st_ == BIAS::ImageBase::ST_invalid) {
    BIAS::ImageBase::EStorageType st;
    BIAS::ImageBase::EColorModel cm;
    // todo how to use cl::Imageformat directly here?
    cl_image_format formatc = src.image().getImageInfo<CL_IMAGE_FORMAT>();
    cl::ImageFormat format(formatc.image_channel_order, formatc.image_channel_data_type);
    DetermineBIASFormat_(format, st, cm);
    Allocate(st,cm, src.width_, src.height_, src.stride_, readonly, writeonly);
  } else {
    Allocate(src.st_, src.cm_, src.width_, src.height_, src.stride_, readonly, writeonly);
  }
}

void clfImage2D::AllocateFromTexture2D(BIAS::glfTexture2D &tex, bool readonly, bool writeonly) {
  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly);
  cl_int err=0;
  try {
#ifdef CL_VERSION_1_2
    buffer_ = cl::ImageGL(*context_, cl_mem_flags, tex.GetTextureTarget(), 0, tex.GetTextureID());
#else
    buffer_ = cl::Image2DGL(*context_, cl_mem_flags, tex.GetTextureTarget(), 0, tex.GetTextureID(),&err);
#endif
    size_t memsize=0;
    buffer_.getInfo(CL_MEM_SIZE, &memsize);
    size_ = memsize;
    /* todo this needs to be pulled from decs
    width_ = tex.GetAllocWidth();
    height_ = tex.GetAllocHeight();
    st_ = tex.GetStorageType();
    cm_ = tex.GetColorModel();
    */
    width_ = 0;
    height_ = 0;
    st_ = ImageBase::ST_float;
    cm_ = ImageBase::CM_RGBA;
    //    st_ = ImageBase::ST_float;
    if (size_ == 0) {// nvidia bug?? is always 0 on nv // changed from NULL to 0
      BIASWARNONCE("cl image memory size reported 0. nvidia bug?");
      size_ = BIAS::ImageBase::GetStorageSizeByte(width_,height_,BIAS::ImageBase::GetChannelcount(cm_), st_);
    }
  } catch(cl::Error &e) {
    THROW_CL_EXCEPTION(e);
  }
  initialized_ = true;
  sharedGL_ = true;
  tex_ = &tex;
}

cl::Image2D& clfImage2D::image() const {
  return (cl::Image2D&)buffer_;
}

void clfImage2D::WriteToImage(const void *data, unsigned int originX, unsigned int originY, unsigned int regionX, unsigned int regionY, bool blocking) {
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  cl::size_t<3> origin, region;
  MakeDim_(origin, originX, originY, 0);
  MakeDim_(region, regionX, regionY, 1);
  
  try {
    if (blocking)
      queue_->enqueueWriteImage(image(), CL_TRUE, origin, region, 0, 0, (void*)data);
    else
      queue_->enqueueWriteImage(image(), CL_FALSE, origin, region, 0, 0, (void*)data);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

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

void clfImage2D::CopyToImage(clfImage2D &outputimage, unsigned int srcoriginX, unsigned int srcoriginY, unsigned int dstoriginX, unsigned int dstoriginY, unsigned int regionX, unsigned int regionY, bool blocking) {
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  cl::size_t<3> srcorigin, dstorigin, region;
  MakeDim_(srcorigin, srcoriginX, srcoriginY, 0);
  MakeDim_(dstorigin, dstoriginX, dstoriginY, 0);
  MakeDim_(region, regionX, regionY, 1);
  try {
    if (blocking) {
      cl::Event event;
      queue_->enqueueCopyImage(image(), outputimage.image(), srcorigin, dstorigin, region, NULL, &event);
      event.wait();
    } else {
      queue_->enqueueCopyImage(image(), outputimage.image(), srcorigin, dstorigin, region);
    }
  } catch (cl::Error &error) {
   // BIASABORT;
    THROW_CL_EXCEPTION(error);
  }
  outputimage.SetMetaData(MetaData_);
}

void* clfImage2D::MapImage(bool write, unsigned int originX, unsigned int originY, unsigned int regionX, unsigned int regionY) {
  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_;
    }
    cl::size_t<3> origin, region;
    MakeDim_(origin, originX, originY, 0);
    MakeDim_(region, regionX, regionY, 1);
    return queue_->enqueueMapImage(image(), CL_TRUE, mapflags, origin, region, 0, NULL);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
  return NULL;
}

void clfImage2D::CopyToBiasImage(BIAS::ImageBase &image,
    unsigned int originX, unsigned int originY, 
    unsigned int regionX, unsigned int regionY) {
  
  if (regionX == 0) {
    regionX = width_;
  }
  if (regionY == 0) {
    regionY = height_;
  }
  if (cm_ == BIAS::ImageBase::CM_invalid || st_ == BIAS::ImageBase::ST_invalid) {
    // todo really set for image?
    cl_image_format formatc = this->image().getImageInfo<CL_IMAGE_FORMAT>();
    cl::ImageFormat format(formatc.image_channel_order, formatc.image_channel_data_type);
    DetermineBIASFormat_(format, st_, cm_);
  }
//  int sx = regionX - originX;
//  int sy = regionY - originY;
  if (!image.IsEmpty()) {
    if (regionX == (int)image.GetWidth() && regionY == (int)image.GetHeight() && cm_ == image.GetColorModel() && st_ == image.GetStorageType()) {
      // is already correctly initialized
    } else {
      if (st_ == image.GetStorageType()) {
      image.Release(false);
      } else {
        image.Release(true);
      }
      image.Init(regionX,regionY, BIAS::ImageBase::GetChannelcount(cm_), st_);
    }
  } else {
    image.Init(regionX,regionY, BIAS::ImageBase::GetChannelcount(cm_), st_);
  }
  ReadFromImage( image.GetImageData(), originX, originY, regionX, regionY );
  image.SetMetaData(MetaData_);
  image.SetColorModel(cm_);
}

void clfImage2D::CopyToBiasImageUncheckedRGBAToRGB(BIAS::ImageBase &image) {
  if (cm_ != BIAS::ImageBase::CM_RGBA || image.GetColorModel() != BIAS::ImageBase::CM_RGB) {
    cl::Error err(-100, "only for rgba->rgb conversion");
    THROW_CL_EXCEPTION(err);
  }
  unsigned int depth = image.GetByteDepth();
  unsigned char *cldata = (unsigned char*)MapImage(false);
  unsigned char *data = (unsigned char*)image.GetImageData();
  for (unsigned int x=0;x<width_*height_;x++) {
    for (unsigned int byte=0;byte<depth;byte++) {
      *data++ = *cldata++;
    }
    for (unsigned int byte=0;byte<depth;byte++) {
      *data++ = *cldata++;
    }
    for (unsigned int byte=0;byte<depth;byte++) {
      *data++ = *cldata++;
    }
    for (unsigned int byte=0;byte<depth;byte++) {
      cldata++;
    }
  }
  UnMap(cldata);
  image.SetMetaData(MetaData_);
}

void clfImage2D::SetStorageAndColorModelInfo(const BIAS::ImageBase::EStorageType &st, const BIAS::ImageBase::EColorModel &cm) {
  if (IsSharedGL()) {
    st_ = st;
    cm_ = cm;
  } else {
    cl::Error err(-100, "only for shared gl textures");
    THROW_CL_EXCEPTION(err);
  }
}

std::vector<std::string> clfImage2D::GetSupportedImageFormats(bool readonly, bool writeonly) {
  std::vector<cl::ImageFormat> *dat = NULL;
  if (readonly) {
    dat = &clfImage2D::imageFormatsReadable_;
  } else if (writeonly) {
    dat = &clfImage2D::imageFormatsWritable_;
  } else {
    dat = &clfImage2D::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 clfImage2D::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:
    case BIAS::ImageBase::CM_UYVY422:
      format.image_channel_order = CL_RG;
      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;
}

void clfImage2D::DetermineBIASFormat_(cl::ImageFormat format, BIAS::ImageBase::EStorageType &st, BIAS::ImageBase::EColorModel &cm) {
  switch (format.image_channel_data_type) {
  case CL_UNSIGNED_INT8:
    st = BIAS::ImageBase::ST_unsignedchar;
    break;
  case CL_UNSIGNED_INT16:
    st = BIAS::ImageBase::ST_unsignedshortint;
    break;
  case CL_UNSIGNED_INT32:
    st = BIAS::ImageBase::ST_unsignedint;
    break;
  case CL_FLOAT:
    st = BIAS::ImageBase::ST_float;
    break;
  default:
    st = BIAS::ImageBase::ST_invalid;
    break;
  }

  switch (format.image_channel_order) {
    case CL_R:
    case CL_INTENSITY:
      cm = BIAS::ImageBase::CM_Grey;
      break;
    case CL_RA:
    case CL_RG:
      cm = BIAS::ImageBase::CM_GreyA;
      break;
    case CL_RGB:
      cm = BIAS::ImageBase::CM_RGB;
      break;
    case CL_RGBA:
      cm = BIAS::ImageBase::CM_RGBA;
      break;
    default:
      cm = BIAS::ImageBase::CM_invalid;
      break;
  }
}


bool clfImage2D::GetFormatSupported_(cl::ImageFormat test, bool readonly, bool writeonly) {
  std::vector<cl::ImageFormat> *dat = NULL;
  if (readonly) {
    dat = &clfImage2D::imageFormatsReadable_;
  } else if (writeonly) {
    dat = &clfImage2D::imageFormatsWritable_;
  } else {
    dat = &clfImage2D::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 clfImage2D::MakeDim_(cl::size_t<3> &dest, int x, int y, int z) {
  dest[0] = x;
  dest[1] = y;
  dest[2] = z;
}