clfImage2D.hh

/* 
 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
 */

#ifndef CLFIMAGE2D_HH_
#define CLFIMAGE2D_HH_

#include <bias_config.h>
#include <Base/Common/BIASpragmaStart.hh>
#include <Base/Image/MetaData.hh>
#include <OpenCLFramework/clfOpenCL.hh>
#include <OpenCLFramework/clfMemory.hh>
#include <OpenGLFramework/Base/glfTexture2D.hh>

namespace BIAS {
  
  /**
   * 
   * @brief OpenCL Image2D wrapper
   * 
   * An clfImage2D is used for both cl::Images, host and GL objects.
   * All buffers are created from a valid clfContext, hence the constructor is protected.
   * 
   * @author fkellner 06/11
   */
  class BIASOpenCLFramework_EXPORT clfImage2D : public clfMemory {
    public:

      virtual ~clfImage2D();
      
      /**
       * @brief Allocation of a memory buffer as 2D image, either call directly or use wrapper for BIAS::ImageBase
       */
      void Allocate(
          BIAS::ImageBase::EStorageType st, BIAS::ImageBase::EColorModel cm,
          unsigned int width, unsigned int height, unsigned int stride=0,
          bool readonly=false, bool writeonly=false, const void *hostptr = NULL, bool copy = false);

      /**
       * @brief Allocation of a memory buffer as 2D image, either call directly or use wrapper for BIAS::ImageBase
       */
      void AllocateFromBiasImage(const BIAS::ImageBase &image, bool readonly=false, bool writeonly=false, bool copy = false);
      
      void AllocateFromBiasTemplate(const BIAS::ImageBase &image, bool readonly=false, bool writeonly=false);

      void AllocateFromTemplate(const clfImage2D &src, bool readonly=false, bool writeonly=false);

      /**
       * @brief Allocation of a memory buffer from a GL Texture2D (works only on shared context!)
       */
      void AllocateFromTexture2D(BIAS::glfTexture2D &tex, bool readonly=false, bool writeonly=false);
      
      inline unsigned int Width() const { return width_; }
      inline unsigned int Height() const { return height_; }
      inline unsigned int Stride() const { return stride_; }
      inline BIAS::ImageBase::EColorModel ColorModel() const { return cm_; }
      inline BIAS::ImageBase::EStorageType StorageType() const { return st_; }
      
      /// @brief write from host memory to image
      void WriteToImage(const void *data, 
          unsigned int originX=0, unsigned int originY=0, 
          unsigned int regionX=0, unsigned int regionY=0,
          bool blocking = true);

      /// @brief read from image to host memory
      void ReadFromImage(void *data, 
          unsigned int originX=0, unsigned int originY=0, 
          unsigned int regionX=0, unsigned int regionY=0);

      void CopyToImage(clfImage2D &outputimage, 
          unsigned int srcoriginX=0, unsigned int srcoriginY=0, 
          unsigned int dstoriginX=0, unsigned int dstoriginY=0, 
          unsigned int regionX=0, unsigned int regionY=0,
          bool blocking = true);
      
      void* MapImage(bool write = false,
          unsigned int originX=0, unsigned int originY=0, 
          unsigned int regionX=0, unsigned int regionY=0
          );
      
      void CopyToBiasImage(BIAS::ImageBase &image,
          unsigned int originX=0, unsigned int originY=0, 
          unsigned int regionX=0, unsigned int regionY=0);
      
      void CopyToBiasImageUncheckedRGBAToRGB(BIAS::ImageBase &image);

      std::vector<std::string> GetSupportedImageFormats(bool readonly=false,
                                                        bool writeonly=false);
      
      void GetImageDim(unsigned int &width, unsigned int &height) const {
        width = width_;
        height = height_;
      }

      void SetStorageAndColorModelInfo(const BIAS::ImageBase::EStorageType &st,
                                       const BIAS::ImageBase::EColorModel &cm);

      BIAS::ImageBase::EColorModel GetColorModel() const {
        return cm_;
      }

      BIAS::ImageBase::EStorageType GetStorageType() const {
        return st_;
      }

      unsigned int GetBitDepth() const {
        return bitdepth_;
      }

      void SetBitDepth(unsigned int bitdepth) {
        bitdepth_ = bitdepth;
      }

      BIAS::MetaData *GetMetaData() {
        return &MetaData_;
      }

      void SetMetaData(const BIAS::MetaData &m) {
        MetaData_ = m;
      }

      BIAS::glfTexture2D *GetTexture() {
        return tex_;
      }

      void SetIsSpare(bool spare);

      void LockSpare();
      void UnLockSpare();

      bool IsSpare();
      bool IsSpareInUse();

    protected:
      clfImage2D(cl::Context *context, cl::CommandQueue *queue);
      cl::Image2D& image() const;
      
    private:
      friend class clfContext;
      friend class clfProgram;
      
      cl::ImageFormat DetermineImageFormat_(BIAS::ImageBase::EStorageType st, BIAS::ImageBase::EColorModel cm);
      void DetermineBIASFormat_(cl::ImageFormat format, BIAS::ImageBase::EStorageType &st, BIAS::ImageBase::EColorModel &cm);
      bool GetFormatSupported_(cl::ImageFormat test, bool readonly, bool writeonly);
      void MakeDim_(cl::size_t<3> &dest, int x, int y, int z);

      unsigned int width_, height_, stride_;
      
      BIAS::ImageBase::EStorageType st_;
      BIAS::ImageBase::EColorModel cm_;
      unsigned int bitdepth_;
      
      BIAS::MetaData MetaData_;

      BIAS::glfTexture2D *tex_;

      bool isSpare_, isInUse_;

      static std::vector<cl::ImageFormat> imageFormatsReadable_;
      static std::vector<cl::ImageFormat> imageFormatsWritable_;
      static std::vector<cl::ImageFormat> imageFormatsReadWrite_;
      
  };
}
#include <Base/Common/BIASpragmaEnd.hh>
#endif /* CLFIMAGE2D_HH_ */