#include <GPUCVTexture/TextureRecycler.h>
#include <GPUCVCuda/DataDsc_CUDA_Base.h>
#if _GPUCV_COMPILE_CUDA
#include <GPUCVCuda/GPU_NVIDIA_CUDA.h>
#include <GPUCVTexture/DataDsc_GLTex.h>
#include <GPUCVTexture/Texture.h>
#include <GPUCVTexture/DataDsc_GLBuff.h>
#include <GPUCVTexture/DataDsc_CPU.h>
//==================================================
DataDsc_CUDA_Base::DataDsc_CUDA_Base()
: DataDsc_Base("DataDsc_CUDA_Base")
//,m_deviceDataPtr(NULL)
//,m_pitch(0)
,m_size(0)
,m_memSize(0)
//,m_deviceDataType(CUDA_NO_TYPE)
//,m_glBufferMapped(false)
,m_cudaPixelType(0)
//,m_textureArrayPtr(NULL)
//,m_textureChannelDesc(NULL)
{
m_data.m_textureArrayPtr = NULL;
m_data.m_deviceDataPtr = NULL;
}
//==================================================
DataDsc_CUDA_Base::~DataDsc_CUDA_Base(void)
{
CLASS_FCT_SET_NAME("~DataDsc_CUDA_Base");
CLASS_DEBUG("");
//Free(); //is done in ~DataDsc_Base()
}
//=======================================================
/*virtual*/
std::string DataDsc_CUDA_Base::LogException(void)
{
std::string Msg;
Msg = CL_Profiler::LogException();
GPU_NVIDIA_CUDA * CudaGPU = dynamic_cast<GPU_NVIDIA_CUDA*>(ProcessingGPU());
if(CudaGPU)
{
Msg+=CudaGPU->GetMemUsage();
}
return Msg;
}
//==================================================
/*virtual*/
void DataDsc_CUDA_Base::SetFormat(const GLuint _pixelFormat,const GLuint _pixelType)
{
DataDsc_Base::SetFormat(_pixelFormat,_pixelType);
m_nChannels = GetGLNbrComponent(_pixelFormat);
//... find internal format...??
}
//==================================================
/*virtual*/
bool DataDsc_CUDA_Base::CopyTo(DataDsc_Base* _destination, bool _datatransfer/*=true*/)
{
CLASS_FCT_SET_NAME_TPL_STR(_destination->GetDscType(),"CopyTo");
TEXTUREDESC_COPY_START(_destination,_datatransfer);
//don't know how to copy...must be done in another object
return false;
}
//==================================================
/*virtual*/
bool DataDsc_CUDA_Base::CopyFrom(DataDsc_Base* _source, bool _datatransfer/*=true*/)
{
CLASS_FCT_SET_NAME_TPL_STR(_source->GetDscType(),"CopyFrom");
TEXTUREDESC_COPY_START(_source,_datatransfer);
//don't know how to copy...must be done in another object
return false;
}
//==================================================
/*virtual*/
DataDsc_Base * DataDsc_CUDA_Base::Clone(DataDsc_CUDA_Base * _src, bool _datatransfer/*=true*/)
{
CLASS_FCT_SET_NAME("Clone");
CLASS_FCT_PROF_CREATE_START();
DataDsc_Base::Clone(_src, _datatransfer);
Free();
m_memSize = _src->m_memSize;
m_size = _src->m_size;
return this;
}
//==================================================
/*virtual*/
DataDsc_Base * DataDsc_CUDA_Base::CloneToNew(bool _datatransfer/*=true*/)
{
DataDsc_CUDA_Base * TempTex = new DataDsc_CUDA_Base();
return TempTex->Clone(this,_datatransfer);
}
//==================================================
/*virtual*/
void DataDsc_CUDA_Base::Allocate()
{
CLASS_FCT_SET_NAME("Allocate");
CLASS_FCT_PROF_CREATE_START();
if(!IsAllocated())
{
m_size = _GetWidth() * _GetHeight() * _GetNChannels();
//bool result = false;
CLASS_DEBUG("Allocate device buffer");
#if 0//_GPUCV_DEBUG_MODE
GPU_NVIDIA_CUDA * CudaGPU = dynamic_cast<GPU_NVIDIA_CUDA*>(ProcessingGPU());
if(CudaGPU)
{
GPUCV_DEBUG(CudaGPU->GetMemUsage());
}
#endif
GCU_Assert(m_cudaPixelType, "Empty m_cudaPixelType");
_AllocateDevice(m_cudaPixelType);
GCU_Assert(m_memSize, "empty memory size after device allocation!");
#if 0// _GPUCV_DEBUG_MODE
if(CudaGPU)
{
GPUCV_DEBUG(CudaGPU->GetMemUsage());
}
#endif
}
}
//==================================================
/*virtual */
void DataDsc_CUDA_Base::_AllocateDevice(unsigned int _datatype)
{
/*
switch(m_cudaPixelType)
{
case CU_AD_FORMAT_UNSIGNED_INT8: result =_DeviceAllocate<unsigned char>();break;
case CU_AD_FORMAT_SIGNED_INT8: result =_DeviceAllocate<char>();break;
case CU_AD_FORMAT_UNSIGNED_INT16: result =_DeviceAllocate<unsigned int>();break;
case CU_AD_FORMAT_SIGNED_INT16: result =_DeviceAllocate<int>();break;
case CU_AD_FORMAT_HALF: result =_DeviceAllocate<float>();break;
case CU_AD_FORMAT_FLOAT: result =_DeviceAllocate<double>();break;
default : GCU_Assert(0,"Critical : DataDsc_CUDA_Base::ConvertPixelType_LocalToGL()=> Unknown pixel type......");
break;
}
*/
}
//==================================================
/*virtual*/
void DataDsc_CUDA_Base::Free()
{
CLASS_FCT_SET_NAME("Free");
CLASS_FCT_PROF_CREATE_START();
DataDsc_Base::Free();
#if _GCU_DEBUG_MEMORY_ALLOC
unsigned int TotalMem=0;
unsigned int FreeMem=0;
cuMemGetInfo(&FreeMem,&TotalMem);
CLASS_NOTICE("");
GPUCV_NOTICE("AFTER=> Cuda free memory:" << FreeMem << "(" << (double)FreeMem/TotalMem*100. <<"%)");
#endif
}
//==================================================
/*virtual*/
bool DataDsc_CUDA_Base::IsAllocated()const
{
if(m_data.m_textureArrayPtr || m_data.m_deviceDataPtr)
return true;
return false;
}
//==================================================
void * DataDsc_CUDA_Base::_GetDataPtr(void)
{
if(!IsAllocated())
Allocate();
return m_data.m_deviceDataPtr;//this is a union...so it should work in every cases
}
//==================================================
/*static virtual*/
void DataDsc_CUDA_Base::ConvertPixelFormat_GLToLocal(const GLuint _pixelFormat)
{
CLASS_FCT_SET_NAME("ConvertPixelFormat_GLToLocal");
//CLASS_ASSERT(0, "DataDsc_CUDA_Base::ConvertPixelFormat_GLToLocal()=>No conversion available yet");
CLASS_WARNING("No conversion available yet");
//m_glPixelFormat = _pixelFormat;
}
//==================================================
/*static virtual*/
GLuint DataDsc_CUDA_Base::ConvertPixelFormat_LocalToGL(void)
{
CLASS_FCT_SET_NAME("ConvertPixelFormat_LocalToGL");
//CLASS_ASSERT(0, "DataDsc_CUDA_Base::ConvertPixelFormat_GLToLocal()=>No conversion available yet");
CLASS_WARNING("No conversion available yet");
return m_glPixelFormat;
}
//==================================================
/*static virtual*/
void DataDsc_CUDA_Base::ConvertPixelType_GLToLocal(const GLuint _pixelType)
{
// m_glPixelType = _pixelType;
switch (_pixelType)
{
case GL_UNSIGNED_BYTE : m_cudaPixelType = CU_AD_FORMAT_UNSIGNED_INT8; break;
case GL_BYTE : m_cudaPixelType = CU_AD_FORMAT_SIGNED_INT8; break;
case GL_UNSIGNED_SHORT : m_cudaPixelType = CU_AD_FORMAT_UNSIGNED_INT16; break;
case GL_SHORT : m_cudaPixelType = CU_AD_FORMAT_SIGNED_INT16; break;
case GL_UNSIGNED_INT : m_cudaPixelType = CU_AD_FORMAT_UNSIGNED_INT32;break;
case GL_INT : m_cudaPixelType = CU_AD_FORMAT_SIGNED_INT32;break;
case GL_FLOAT : m_cudaPixelType = CU_AD_FORMAT_HALF;break;//????
case GL_RGBA_FLOAT32_ATI:
case GL_RGBA_FLOAT16_ATI: m_cudaPixelType = CU_AD_FORMAT_FLOAT;break;
default : GPUCV_ERROR("Critical : DataDsc_CUDA_Base::ConvertPixelType_GLToLocal()=> Unknown pixel type...Using GL_UNSIGNED_INT...");
m_cudaPixelType = CU_AD_FORMAT_SIGNED_INT16;
break;
}
}
//==================================================
/*static virtual*/
GLuint DataDsc_CUDA_Base::ConvertPixelType_LocalToGL(void)
{
GLuint PixelType;
switch (m_cudaPixelType)
{
case CU_AD_FORMAT_UNSIGNED_INT8: PixelType = GL_UNSIGNED_BYTE;break;
case CU_AD_FORMAT_SIGNED_INT8: PixelType = GL_BYTE;break;
case CU_AD_FORMAT_UNSIGNED_INT16: PixelType = GL_UNSIGNED_SHORT;break;
case CU_AD_FORMAT_SIGNED_INT16: PixelType = GL_SHORT;break;
case CU_AD_FORMAT_UNSIGNED_INT32: PixelType = GL_UNSIGNED_INT;break;
case CU_AD_FORMAT_SIGNED_INT32: PixelType = GL_INT;break;
case CU_AD_FORMAT_HALF: PixelType = GL_FLOAT;break;
case CU_AD_FORMAT_FLOAT: PixelType = GL_RGBA_FLOAT32_ATI;break;
default : GPUCV_ERROR("Critical : DataDsc_CUDA_Base::ConvertPixelType_LocalToGL()=> Unknown pixel type...Using GL_UNSIGNED_INT...");
PixelType = GL_INT;
break;
}
return PixelType;
}
//==================================================
/*virtual*/
std::ostringstream & DataDsc_CUDA_Base::operator << (std::ostringstream & _stream)const
{
DataDsc_Base::operator << (_stream);
_stream << _GPUCV_INDENT_ << "DataDsc_CUDA_Base==============" << std::endl;
_stream << _GPUCV_INDENT_ << "Data size: \t"<< m_size << std::endl;
_stream << _GPUCV_INDENT_ << "Memory size: \t"<< m_memSize << std::endl;
_stream << _GPUCV_INDENT_ << "Pixel type:\t???" << std::endl;
_stream << _GPUCV_INDENT_ << "DataDsc_CUDA_Base==============" << std::endl;
return _stream;
}
//==================================================
//==================================================
//Local functions
//==================================================
//==================================================
//==================================================
//==================================================
#endif//_GPUCV_COMPILE_CUDA
|
