phase_rgb_target_kernel.c

Go to the documentation of this file.

/*
*
* Copyright (c) 2017 Texas Instruments Incorporated
*
* All rights reserved not granted herein.
*
* Limited License.
*
* Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
* license under copyrights and patents it now or hereafter owns or controls to make,
* have made, use, import, offer to sell and sell ("Utilize") this software subject to the
* terms herein.  With respect to the foregoing patent license, such license is granted
* solely to the extent that any such patent is necessary to Utilize the software alone.
* The patent license shall not apply to any combinations which include this software,
* other than combinations with devices manufactured by or for TI ("TI Devices").
* No hardware patent is licensed hereunder.
*
* Redistributions must preserve existing copyright notices and reproduce this license
* (including the above copyright notice and the disclaimer and (if applicable) source
* code license limitations below) in the documentation and/or other materials provided
* with the distribution
*
* Redistribution and use in binary form, without modification, are permitted provided
* that the following conditions are met:
*
* *       No reverse engineering, decompilation, or disassembly of this software is
* permitted with respect to any software provided in binary form.
*
* *       any redistribution and use are licensed by TI for use only with TI Devices.
*
* *       Nothing shall obligate TI to provide you with source code for the software
* licensed and provided to you in object code.
*
* If software source code is provided to you, modification and redistribution of the
* source code are permitted provided that the following conditions are met:
*
* *       any redistribution and use of the source code, including any resulting derivative
* works, are licensed by TI for use only with TI Devices.
*
* *       any redistribution and use of any object code compiled from the source code
* and any resulting derivative works, are licensed by TI for use only with TI Devices.
*
* Neither the name of Texas Instruments Incorporated nor the names of its suppliers
*
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* DISCLAIMER.
*
* THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL TI AND TI'S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#include <TI/tivx.h>
#include <VX/vx.h>
#include <TI/tivx_target_kernel.h>
#include <vx_tutorial_kernels.h>
#include <tivx_kernels_common_utils.h>
#include <tivx_kernels_target_utils.h>

#define PHASE_RGB_IN0_IMG_IDX   (0u)

#define PHASE_RGB_OUT0_IMG_IDX  (1u)

#define PHASE_RGB_MAX_PARAMS    (2u)

static tivx_target_kernel phase_rgb_target_kernel = NULL;

vx_status VX_CALLBACK vxTutotrialPhaseRgb(
    tivx_target_kernel_instance kernel, tivx_obj_desc_t *obj_desc[],
    uint16_t num_params, void *priv_arg)
{
    vx_status status = (vx_status)VX_SUCCESS;
    tivx_obj_desc_image_t *src_desc, *dst_desc;

    if ((num_params != PHASE_RGB_MAX_PARAMS)
        || (NULL == obj_desc[PHASE_RGB_IN0_IMG_IDX])
        || (NULL == obj_desc[PHASE_RGB_OUT0_IMG_IDX])
        )
    {
        status = (vx_status)VX_FAILURE;
    }
    else
    {
        void *src_desc_target_ptr;
        void *dst_desc_target_ptr;

        /* Get the Src and Dst descriptors */
        src_desc = (tivx_obj_desc_image_t *)obj_desc[PHASE_RGB_IN0_IMG_IDX];
        dst_desc = (tivx_obj_desc_image_t *)obj_desc[PHASE_RGB_OUT0_IMG_IDX];

        /* Get the target pointer from the shared pointer for all
           buffers */
        src_desc_target_ptr = tivxMemShared2TargetPtr(&src_desc->mem_ptr[0]);
        dst_desc_target_ptr = tivxMemShared2TargetPtr(&dst_desc->mem_ptr[0]);

        /* Map all buffers, which invalidates the cache */
        tivxCheckStatus(&status, tivxMemBufferMap(src_desc_target_ptr,
            src_desc->mem_size[0], (vx_enum)VX_MEMORY_TYPE_HOST,
            (vx_enum)VX_READ_ONLY));
        tivxCheckStatus(&status, tivxMemBufferMap(dst_desc_target_ptr,
            dst_desc->mem_size[0], (vx_enum)VX_MEMORY_TYPE_HOST,
            (vx_enum)VX_WRITE_ONLY));

        /* Run function for complete image, ROI is ignored in this example */
        {
            vx_uint32 x, y, width, height;
            vx_uint8 *in_data_ptr, *out_data_ptr;
            vx_uint8 *in_pixel, *out_pixel;

            in_data_ptr = src_desc_target_ptr;
            out_data_ptr = dst_desc_target_ptr;

            width = dst_desc->imagepatch_addr[0U].dim_x;
            height = dst_desc->imagepatch_addr[0U].dim_y;

            for(y=0; y<height; y++)
            {
                in_pixel = in_data_ptr;
                out_pixel = out_data_ptr;

                for(x=0; x<width; x++)
                {
                    if(in_pixel[0]<64)
                    {
                        out_pixel[0] = 0xFF;
                        out_pixel[1] = 0x00;
                        out_pixel[2] = 0x00;
                    }
                    else
                    if(in_pixel[0]<128)
                    {
                        out_pixel[0] = 0x00;
                        out_pixel[1] = 0xFF;
                        out_pixel[2] = 0x00;
                    }
                    else
                    if(in_pixel[0]<192)
                    {
                        out_pixel[0] = 0x00;
                        out_pixel[1] = 0x00;
                        out_pixel[2] = 0xFF;
                    }
                    else
                    {
                        out_pixel[0] = 0xFF;
                        out_pixel[1] = 0xFF;
                        out_pixel[2] = 0xFF;
                    }
                    in_pixel++;
                    out_pixel += 3;
                }
                in_data_ptr += src_desc->imagepatch_addr[0U].stride_y;
                out_data_ptr += dst_desc->imagepatch_addr[0U].stride_y;
            }
        }

        tivxCheckStatus(&status, tivxMemBufferUnmap(src_desc_target_ptr,
            src_desc->mem_size[0], (vx_enum)VX_MEMORY_TYPE_HOST,
            (vx_enum)VX_READ_ONLY));
        tivxCheckStatus(&status, tivxMemBufferUnmap(dst_desc_target_ptr,
            dst_desc->mem_size[0], (vx_enum)VX_MEMORY_TYPE_HOST,
            (vx_enum)VX_WRITE_ONLY));

    }

    return (status);
}

vx_status VX_CALLBACK vxTutotrialPhaseRgbCreate(tivx_target_kernel_instance kernel, tivx_obj_desc_t *param_obj_desc[], uint16_t num_params, void *priv_arg)
{
    vx_status status = (vx_status)VX_SUCCESS;

    return status;
}

vx_status VX_CALLBACK vxTutotrialPhaseRgbDelete(tivx_target_kernel_instance kernel, tivx_obj_desc_t *param_obj_desc[], uint16_t num_params, void *priv_arg)
{
    vx_status status = (vx_status)VX_SUCCESS;

    return status;
}

vx_status VX_CALLBACK vxTutotrialPhaseRgbControl(tivx_target_kernel_instance kernel,
    uint32_t replicated_node_idx, tivx_obj_desc_t *param_obj_desc[], uint16_t num_params, void *priv_arg)
{
    vx_status status = (vx_status)VX_SUCCESS;

    return status;
}

void vxTutorialAddTargetKernelPhaseRgb(void)
{
    char target_name[TIVX_TARGET_MAX_NAME];

    if( (vx_status)VX_SUCCESS == tivxKernelsTargetUtilsAssignTargetNameDsp(target_name))
    {

        phase_rgb_target_kernel = tivxAddTargetKernelByName(
                    TIVX_TUTORIAL_KERNEL_PHASE_RGB_NAME,
                    target_name,
                    vxTutotrialPhaseRgb,
                    vxTutotrialPhaseRgbCreate,
                    vxTutotrialPhaseRgbDelete,
                    vxTutotrialPhaseRgbControl,
                    NULL);
    }
}

void vxTutorialRemoveTargetKernelPhaseRgb(void)
{
    vx_status status = (vx_status)VX_SUCCESS;

    status = tivxRemoveTargetKernel(phase_rgb_target_kernel);
    if ((vx_status)VX_SUCCESS == status)
    {
        phase_rgb_target_kernel = NULL;
    }
}