Example #1
0
static vx_status VX_CALLBACK vxSubtractionKernel(vx_node node, const vx_reference *parameters, vx_uint32 num)
{
    if (num == 4)
    {
        vx_image in0 = (vx_image)parameters[0];
        vx_image in1 = (vx_image)parameters[1];
        vx_scalar policy_param = (vx_scalar)parameters[2];
        vx_image output = (vx_image)parameters[3];
        return vxSubtraction(in0, in1, policy_param, output);
    }
    return VX_ERROR_INVALID_PARAMETERS;
}
Example #2
0
static vx_status VX_CALLBACK vxSubtractionKernel(vx_node node, const vx_reference parameters[], vx_uint32 num)
{
    if (num == dimof(add_subtract_kernel_params))
    {
        vx_status status = VX_SUCCESS;
        vx_image  in0           =  (vx_image)parameters[0];
        vx_image  in1           =  (vx_image)parameters[1];
        vx_scalar policy_param  = (vx_scalar)parameters[2];
        vx_image  output        =  (vx_image)parameters[3];

        vx_bool is_replicated = vx_false_e;

        status = vxQueryNode(node, VX_NODE_IS_REPLICATED, &is_replicated, sizeof(is_replicated));
        if (VX_SUCCESS != status)
            return status;

        if (vx_true_e == is_replicated)
        {
            vx_size i;
            vx_bool replicas[VX_INT_MAX_PARAMS] = { vx_false_e };

            status = vxQueryNode(node, VX_NODE_REPLICATE_FLAGS, replicas, sizeof(vx_bool)*num);
            if (VX_SUCCESS != status)
                return status;

            /* if node is replicated, in0, in1 and output params have to be replicated */
            if (vx_true_e == replicas[0] && vx_true_e == replicas[1] &&
                vx_true_e != replicas[2] &&
                vx_true_e == replicas[3])
            {
                /* all params have to be pyramid (supported now) or image arrays (not implemented yet) */
                if (in0->base.scope->type == VX_TYPE_PYRAMID && in1->base.scope->type == VX_TYPE_PYRAMID &&
                    output->base.scope->type == VX_TYPE_PYRAMID)
                {
                    vx_size pyr0_levels = 0;
                    vx_size pyr1_levels = 0;
                    vx_size pyr3_levels = 0;

                    vx_pyramid pyr0 = (vx_pyramid)in0->base.scope;
                    vx_pyramid pyr1 = (vx_pyramid)in1->base.scope;
                    vx_pyramid pyr3 = (vx_pyramid)output->base.scope;

                    status = vxQueryPyramid(pyr0, VX_PYRAMID_LEVELS, &pyr0_levels, sizeof(pyr0_levels));
                    if (VX_SUCCESS != status)
                        return status;

                    status = vxQueryPyramid(pyr1, VX_PYRAMID_LEVELS, &pyr1_levels, sizeof(pyr1_levels));
                    if (VX_SUCCESS != status)
                        return status;

                    status = vxQueryPyramid(pyr3, VX_PYRAMID_LEVELS, &pyr3_levels, sizeof(pyr3_levels));
                    if (VX_SUCCESS != status)
                        return status;

                    if (pyr0_levels != pyr1_levels || pyr0_levels != pyr3_levels)
                        return VX_FAILURE;

                    for (i = 0; i < pyr3_levels; i++)
                    {
                        vx_image src0 = vxGetPyramidLevel(pyr0, i);
                        vx_image src1 = vxGetPyramidLevel(pyr1, i);
                        vx_image dst  = vxGetPyramidLevel(pyr3, i);

                        status = vxSubtraction(src0, src1, policy_param, dst);

                        status |= vxReleaseImage(&src0);
                        status |= vxReleaseImage(&src1);
                        status |= vxReleaseImage(&dst);
                    }
                }
            }
        }
        else
            status = vxSubtraction(in0, in1, policy_param, output);

        return status;
    }

    return VX_ERROR_INVALID_PARAMETERS;
}