Ejemplos de XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN en C++ (Cpp)

Ejemplo n.º 1

Archivo: cl_tnr_handler.cpp Proyecto: weiafu/libxcam

SmartPtr<CLImageHandler>
create_cl_tnr_image_handler (SmartPtr<CLContext> &context, CLTnrType type)
{
    SmartPtr<CLTnrImageHandler> tnr_handler;
    SmartPtr<CLTnrImageKernel> tnr_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_tnr_yuv)
#include "kernel_tnr_yuv.clx"
    XCAM_CL_KERNEL_FUNC_END;

    XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_tnr_rgb)
#include "kernel_tnr_rgb.clx"
    XCAM_CL_KERNEL_FUNC_END;

    if (CL_TNR_TYPE_YUV == type) {
        tnr_kernel = new CLTnrImageKernel (context, "kernel_tnr_yuv", CL_TNR_TYPE_YUV);
        ret = tnr_kernel->load_from_source (kernel_tnr_yuv_body, strlen (kernel_tnr_yuv_body));
    } else if (CL_TNR_TYPE_RGB == type) {
        tnr_kernel = new CLTnrImageKernel (context, "kernel_tnr_rgb", CL_TNR_TYPE_RGB);
        ret = tnr_kernel->load_from_source (kernel_tnr_rgb_body, strlen (kernel_tnr_rgb_body));
    }

    XCAM_FAIL_RETURN (
        WARNING,
        ret == XCAM_RETURN_NO_ERROR,
        NULL,
        "CL image handler(%s) load source failed", tnr_kernel->get_kernel_name());

    tnr_handler = new CLTnrImageHandler ("cl_handler_tnr");
    XCAM_ASSERT (tnr_kernel->is_valid ());
    tnr_handler->set_tnr_kernel (tnr_kernel);

    return tnr_handler;
}

Ejemplo n.º 2

Archivo: cl_bnr_handler.cpp Proyecto: dspmeng/libxcam

SmartPtr<CLImageHandler>
create_cl_bnr_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLBnrImageHandler> bnr_handler;
    SmartPtr<CLBnrImageKernel> bnr_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    bnr_kernel = new CLBnrImageKernel (context);
    {
        XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_bnr)
#include "kernel_bnr.clx"
        XCAM_CL_KERNEL_FUNC_END;
        ret = bnr_kernel->load_from_source (kernel_bnr_body, strlen (kernel_bnr_body));
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", bnr_kernel->get_kernel_name());
    }
    XCAM_ASSERT (bnr_kernel->is_valid ());
    bnr_handler = new CLBnrImageHandler ("cl_handler_bnr");
    bnr_handler->set_simple_kernel (bnr_kernel);

    return bnr_handler;
}

Ejemplo n.º 3

Archivo: cl_demosaic_handler.cpp Proyecto: timehold/libxcam

SmartPtr<CLImageHandler>
create_cl_demosaic_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLImageHandler> demosaic_handler;
    SmartPtr<CLImageKernel> demosaic_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    demosaic_kernel = new CLDemosaicImageKernel (context);
    {
        XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_demosaic)
#include "kernel_demosaic.cl"
        XCAM_CL_KERNEL_FUNC_END;
        ret = demosaic_kernel->load_from_source (kernel_demosaic_body, strlen (kernel_demosaic_body));
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", demosaic_kernel->get_kernel_name());
    }
    XCAM_ASSERT (demosaic_kernel->is_valid ());
    demosaic_handler = new CLBayer2RGBImageHandler ("cl_handler_demosaic");
    demosaic_handler->add_kernel (demosaic_kernel);

    return demosaic_handler;
}

Ejemplo n.º 4

Archivo: cl_gamma_handler.cpp Proyecto: weiafu/libxcam

SmartPtr<CLImageHandler>
create_cl_gamma_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLGammaImageHandler> gamma_handler;
    SmartPtr<CLGammaImageKernel> gamma_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    gamma_kernel = new CLGammaImageKernel (context);
    {
        XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_gamma)
#include "kernel_gamma.clx"
        XCAM_CL_KERNEL_FUNC_END;
        ret = gamma_kernel->load_from_source (kernel_gamma_body, strlen (kernel_gamma_body));
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", gamma_kernel->get_kernel_name());
    }
    XCAM_ASSERT (gamma_kernel->is_valid ());
    gamma_handler = new CLGammaImageHandler ("cl_handler_gamma");
    gamma_handler->set_gamma_kernel (gamma_kernel);

    return gamma_handler;
}

Ejemplo n.º 5

Archivo: cl_rgb_pipe_handler.cpp Proyecto: dspmeng/libxcam

SmartPtr<CLImageHandler>
create_cl_rgb_pipe_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLRgbPipeImageHandler> rgb_pipe_handler;
    SmartPtr<CLRgbPipeImageKernel> rgb_pipe_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rgb_pipe_kernel = new CLRgbPipeImageKernel (context);
    {
        XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_rgb_pipe)
#include "kernel_rgb_pipe.clx"
        XCAM_CL_KERNEL_FUNC_END;
        ret = rgb_pipe_kernel->load_from_source (kernel_rgb_pipe_body, strlen (kernel_rgb_pipe_body));
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", rgb_pipe_kernel->get_kernel_name());
    }
    XCAM_ASSERT (rgb_pipe_kernel->is_valid ());
    rgb_pipe_handler = new CLRgbPipeImageHandler ("cl_handler_rgb_pipe");
    rgb_pipe_handler->set_rgb_pipe_kernel  (rgb_pipe_kernel);

    return rgb_pipe_handler;
}

Ejemplo n.º 6

Archivo: cl_wavelet_denoise_handler.cpp Proyecto: wang-fei/libxcam

SmartPtr<CLImageHandler>
create_cl_wavelet_denoise_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLWaveletDenoiseImageHandler> wavelet_handler;
    SmartPtr<CLWaveletDenoiseImageKernel> wavelet_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_wavelet_denoise)
#include "kernel_wavelet_denoise.clx"
    XCAM_CL_KERNEL_FUNC_END;

    wavelet_handler = new CLWaveletDenoiseImageHandler ("cl_handler_wavelet_denoise");
    XCAM_ASSERT (wavelet_handler.ptr ());

    for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
        wavelet_kernel = new CLWaveletDenoiseImageKernel (context, "kernel_wavelet_denoise", wavelet_handler, layer);

        ret = wavelet_kernel->load_from_source (
                  kernel_wavelet_denoise_body, strlen (kernel_wavelet_denoise_body),
                  NULL, NULL,
                  WAVELET_DENOISE_UV ? "-DWAVELET_DENOISE_UV=1" : "-DWAVELET_DENOISE_UV=0");
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", wavelet_kernel->get_kernel_name());

        XCAM_ASSERT (wavelet_kernel->is_valid ());

        SmartPtr<CLImageKernel> image_kernel = wavelet_kernel;
        wavelet_handler->add_kernel (image_kernel);
    }
    return wavelet_handler;
}

Ejemplo n.º 7

Archivo: cl_wb_handler.cpp Proyecto: chivakker/libxcam

SmartPtr<CLImageHandler>
create_cl_wb_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLWbImageHandler> wb_handler;
    SmartPtr<CLWbImageKernel> wb_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    wb_kernel = new CLWbImageKernel (context);
    {
        XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_wb)
#include "kernel_wb.cl"
        XCAM_CL_KERNEL_FUNC_END;
        ret = wb_kernel->load_from_source (kernel_wb_body, strlen (kernel_wb_body));
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", wb_kernel->get_kernel_name());
    }
    XCAM_ASSERT (wb_kernel->is_valid ());
    wb_handler = new CLWbImageHandler ("cl_handler_wb");
    wb_handler->set_wb_kernel (wb_kernel);

    return wb_handler;
}

Ejemplo n.º 8

Archivo: cl_newtonemapping_handler.cpp Proyecto: eval-printer/libxcam

SmartPtr<CLImageHandler>
create_cl_newtonemapping_image_handler (SmartPtr<CLContext> &context)
{
    SmartPtr<CLNewTonemappingImageHandler> tonemapping_handler;
    SmartPtr<CLNewTonemappingImageKernel> tonemapping_kernel;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    tonemapping_kernel = new CLNewTonemappingImageKernel (context, "kernel_newtonemapping");
    {
        XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_newtonemapping)
#include "kernel_newtonemapping.clx"
        XCAM_CL_KERNEL_FUNC_END;
        ret = tonemapping_kernel->load_from_source (kernel_newtonemapping_body, strlen (kernel_newtonemapping_body));
        XCAM_FAIL_RETURN (
            WARNING,
            ret == XCAM_RETURN_NO_ERROR,
            NULL,
            "CL image handler(%s) load source failed", tonemapping_kernel->get_kernel_name());
    }
    XCAM_ASSERT (tonemapping_kernel->is_valid ());
    tonemapping_handler = new CLNewTonemappingImageHandler("cl_handler_newtonemapping");
    tonemapping_handler->set_tonemapping_kernel(tonemapping_kernel);

    return tonemapping_handler;
}