CLTexImage.cpp

Go to the documentation of this file.

//  File:       CLTexImage.cpp
//  Author:     Changchang Wu
//  Description : implementation of the CLTexImage class.
//
//  Copyright (c) 2007 University of North Carolina at Chapel Hill
//  All Rights Reserved
//
//  Permission to use, copy, modify and distribute this software and its
//  documentation for educational, research and non-profit purposes, without
//  fee, and without a written agreement is hereby granted, provided that the
//  above copyright notice and the following paragraph appear in all copies.
//  
//  The University of North Carolina at Chapel Hill make no representations
//  about the suitability of this software for any purpose. It is provided
//  'as is' without express or implied warranty. 
//
//  Please send BUG REPORTS to ccwu@cs.unc.edu
//
 
#if defined(CL_SIFTGPU_ENABLED)
 
#include "GL/glew.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <stdlib.h>
#include <math.h>
using namespace std;
 
 
#include <CL/OpenCL.h>
#include "CLTexImage.h" 
#include "ProgramCL.h"
#include "GlobalUtil.h"
 
 
CLTexImage::CLTexImage()
{
    _context = NULL;
    _queue = NULL;
    _clData = NULL;
    _numChannel = _bufferLen = _fromGL = 0;
    _imgWidth = _imgHeight = _texWidth = _texHeight = 0;
}
 
CLTexImage::CLTexImage(cl_context context, cl_command_queue queue)
{
    _context = context;
    _queue  = queue;
    _clData = NULL;
    _numChannel = _bufferLen = _fromGL = 0;
    _imgWidth = _imgHeight = _texWidth = _texHeight = 0;
}
 
void CLTexImage::SetContext(cl_context context, cl_command_queue queue)
{
    _context = context;
    _queue   = queue;
}
 
 
CLTexImage::~CLTexImage()
{
    ReleaseTexture();
}
 
void CLTexImage::ReleaseTexture()
{
    if(_fromGL)     clEnqueueReleaseGLObjects(_queue, 1, &_clData, 0, NULL, NULL); 
    if(_clData)     clReleaseMemObject(_clData);
}
 
void CLTexImage::SetImageSize(int width, int height)
{
    _imgWidth = width;
    _imgHeight = height;
}
 
void CLTexImage::InitBufferTex(int width, int height, int nchannel)
{
    if(width == 0 || height == 0 || nchannel <= 0 || _fromGL) return; 
 
    _imgWidth = width;  _imgHeight = height;
    _texWidth = _texHeight = _fromGL = 0; 
    _numChannel = min(nchannel, 4);
 
    int size = width * height * _numChannel * sizeof(float);
    if (size <= _bufferLen) return;
    
    //allocate the buffer data
    cl_int status; 
    if(_clData) status = clReleaseMemObject(_clData);
 
    _clData = clCreateBuffer(_context, CL_MEM_READ_WRITE, 
                            _bufferLen = size, NULL, &status);
 
    ProgramBagCL::CheckErrorCL(status, "CLTexImage::InitBufferTex");
 
}
 
void CLTexImage::InitTexture(int width, int height, int nchannel)
{
    if(width == 0 || height == 0 || nchannel <= 0 || _fromGL) return; 
    if(_clData && width == _texWidth && height == _texHeight && _numChannel == nchannel) return;
    if(_clData) clReleaseMemObject(_clData);
 
    _texWidth = _imgWidth =  width;
    _texHeight = _imgHeight =  height;
    _numChannel = nchannel; 
    _bufferLen = _fromGL = 0; 
 
    cl_int status;    cl_image_format format;
 
    if(nchannel == 1) format.image_channel_order = CL_R;
    else if(nchannel == 2) format.image_channel_order = CL_RG;
    else if(nchannel == 3) format.image_channel_order = CL_RGB;
    else format.image_channel_order = CL_RGBA;
 
    format.image_channel_data_type = CL_FLOAT;
    _clData = clCreateImage2D(_context, CL_MEM_READ_WRITE, & format, 
                    _texWidth, _texHeight, 0, 0, &status);
    ProgramBagCL::CheckErrorCL(status, "CLTexImage::InitTexture");
}
 
void CLTexImage::InitPackedTex(int width, int height, int packed)
{
    if(packed) InitTexture((width + 1) >> 1, (height + 1) >> 1, 4);
    else InitTexture(width, height, 1);
}
 
void CLTexImage::SetPackedSize(int width, int height, int packed)
{
    if(packed)  SetImageSize((width + 1) >> 1, (height + 1) >> 1);
    else SetImageSize(width, height);
}
 
void CLTexImage::InitTextureGL(GLuint tex, int width, int height, int nchannel)
{
    if(tex == 0) return;
    if(_clData) clReleaseMemObject(_clData); 
 
    cl_int status;
    _clData = clCreateFromGLTexture2D(_context, CL_MEM_WRITE_ONLY, 
        GlobalUtil::_texTarget, 0 , tex, &status);
    ProgramBagCL::CheckErrorCL(status, "CLTexImage::InitTextureGL->clCreateFromGLTexture2D");
    if(status != CL_SUCCESS) return; 
 
    _texWidth = _imgWidth = width;
    _texHeight = _imgHeight = height;
    _numChannel = nchannel;
    _bufferLen = 0;    _fromGL = 1; 
 
    status = clEnqueueAcquireGLObjects(_queue, 1, &_clData, 0, NULL, NULL); 
    ProgramBagCL::CheckErrorCL(status, "CLTexImage::InitTextureGL->clEnqueueAcquireGLObjects");
 
}
 
void CLTexImage::CopyFromHost(const void * buf)
{
    if(_clData == NULL) return;
    cl_int status; 
    if(_bufferLen)
    {
        status = clEnqueueWriteBuffer(_queue, _clData, false,  0, 
            _imgWidth * _imgHeight * _numChannel * sizeof(float),  buf,  0, NULL, NULL);
    }else
    {
        size_t origin[3] = {0, 0, 0}, region[3] = {_imgWidth, _imgHeight, 1};
        size_t row_pitch = _imgWidth * _numChannel * sizeof(float);
        status = clEnqueueWriteImage(_queue, _clData, false, origin,
            region, row_pitch, 0, buf, 0, 0, 0);  
    }
    ProgramBagCL::CheckErrorCL(status, "CLTexImage::CopyFromHost");
}
 
int CLTexImage::GetImageDataSize()
{
    return _imgWidth * _imgHeight * _numChannel * sizeof(float);
}
 
int CLTexImage::CopyToPBO(GLuint pbo)
{
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);  
 
    int esize = GetImageDataSize(), bsize;
    glGetBufferParameteriv(GL_PIXEL_UNPACK_BUFFER_ARB, GL_BUFFER_SIZE, &bsize);
    if(bsize < esize)
    {
        glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, esize, NULL, GL_STATIC_DRAW_ARB);
        glGetBufferParameteriv(GL_PIXEL_UNPACK_BUFFER_ARB, GL_BUFFER_SIZE, &bsize);
    }
    if(bsize >= esize)
    {
        // map the buffer object into client's memory
        void* ptr = glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB);
        CopyToHost(ptr); 
        clFinish(_queue);
        glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB); 
    }
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);  
    GlobalUtil::CheckErrorsGL("CLTexImage::CopyToPBO");
    return esize >= bsize;
}
 
void CLTexImage::CopyToHost(void * buf)
{
    if(_clData == NULL) return;
    cl_int status;
    if(_bufferLen)
    { 
        status = clEnqueueReadBuffer(_queue, _clData, true,  0, 
            _imgWidth * _imgHeight * _numChannel * sizeof(float), buf,  0, NULL, NULL);
    }else
    {
        size_t origin[3] = {0, 0, 0}, region[3] = {_imgWidth, _imgHeight, 1};
        size_t row_pitch = _imgWidth * _numChannel * sizeof(float);
        status = clEnqueueReadImage(_queue, _clData, true, origin,
            region, row_pitch, 0, buf, 0, 0, 0);
    }
 
    ProgramBagCL::CheckErrorCL(status, "CLTexImage::CopyToHost");
}
 
#endif