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

using namespace BIAS;

clfBuffer::clfBuffer(cl::Context *context, cl::CommandQueue *queue) : clfMemory(context, queue) {
  rows_=0;
  cols_=0;
  itemsize_=0;
  stride_=0;
  channels_ = 1;
  cache_ = false;
}

clfBuffer::~clfBuffer() {
  //TODO: Do we need to free memory if allocated???
}

void clfBuffer::Allocate(unsigned int bufsize, bool readonly, bool writeonly, void *hostptr, bool copy) {
  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly, hostptr, copy);
  if (initialized_ && !sharedGL_ && size_ == bufsize) {
    // already allocated with correct size
    return;
  }
  size_ = bufsize;
  try {
    buffer_ = cl::Buffer(*context_, cl_mem_flags, size_, hostptr);
  } catch(cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
  initialized_ = true;
  sharedGL_ = false;
}

void clfBuffer::Allocate(unsigned int rows, unsigned int cols, unsigned int channels, unsigned int itemsize, bool readonly, bool writeonly, void *hostptr, bool copy) {
  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly, hostptr, copy);
  if (cache_) {
    if (readonly) {
      cl_mem_flags = CL_READ_ONLY_CACHE;
    } else {
      cl_mem_flags = CL_READ_WRITE_CACHE;
    }
  }
  if (initialized_ && !sharedGL_ && size_ == rows*cols*itemsize) {
    // already allocated with correct size, just grab new values
    size_ = rows*cols*itemsize;
    rows_=rows;
    cols_=cols;
    channels_ = channels;
    itemsize_=itemsize;
    stride_=cols*itemsize;
    return;
  }
  size_ = rows*cols*itemsize*channels;
  rows_=rows;
  cols_=cols;
  itemsize_=itemsize;
  stride_=cols*itemsize;
  channels_=channels;

  try {
    buffer_ = cl::Buffer(*context_, cl_mem_flags, size_, hostptr);
  } catch(cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
  initialized_ = true;
  sharedGL_ = false;
}

void clfBuffer::AllocateFromVertexBuffer(BIAS::glfVertexBuffer &vbo, bool readonly, bool writeonly) {
  int cl_mem_flags = DetermineMemFlags_(readonly, writeonly);
  try {
    buffer_ = cl::BufferGL(*context_, cl_mem_flags, vbo.GetBufferID());
  } catch(cl::Error &err) {
    THROW_CL_EXCEPTION(err);
  }
  size_ = vbo.GetNumVertices()*vbo.GetFormat().GetVertexSize();
  initialized_ = true;
  sharedGL_ = true;
  glid_ = vbo.GetBufferID(); 
}

void clfBuffer::SetCached(bool cache) {
  cache_ = cache;
}

cl::Buffer& clfBuffer::buffer() {
  return (cl::Buffer&)buffer_;
}

void clfBuffer::WriteToBuffer(const void *data, unsigned int offset, unsigned int size) {
  if (size == 0) {
    size = size_;
  }
  try {
    queue_->enqueueWriteBuffer(buffer(), CL_TRUE, offset, size, data);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

void clfBuffer::ReadFromBuffer(void *data, unsigned int offset, unsigned int size) {
  if (size == 0) {
    size = size_;
  }
  try {
    queue_->enqueueReadBuffer(buffer(), CL_TRUE, offset, size, data);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

void clfBuffer::CopyBuffer(clfBuffer &outputbuffer, unsigned int srcoffset, unsigned int dstoffset, unsigned int size) {
  if (size == 0) {
    size = size_;
  }
  try {
    cl::Event event;
    queue_->enqueueCopyBuffer(buffer(), outputbuffer.buffer(), srcoffset, dstoffset, size, NULL, &event);
    event.wait();
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
}

void* clfBuffer::MapBuffer(bool write, unsigned int offset, unsigned int size) {
  try {
    cl_map_flags mapflags = 0;
    if (write) { 
      mapflags = CL_MAP_WRITE;
    } else { 
      mapflags = CL_MAP_READ;
    }
    if (size == 0) {
      size = size_;
    }
    return queue_->enqueueMapBuffer(buffer(), CL_TRUE, mapflags, offset, size);
  } catch (cl::Error &error) {
    THROW_CL_EXCEPTION(error);
  }
  return NULL;
}

unsigned int clfBuffer::GetRows() const {
  return rows_;
}
unsigned int clfBuffer::GetCols() const {
  return cols_;
}
unsigned int clfBuffer::GetItemSize() const {
  return itemsize_;
}
unsigned int clfBuffer::GetStride() const {
  return stride_;
}

unsigned int clfBuffer::GetChannels() const {
  return channels_;
}