348 lines
13 KiB
C
348 lines
13 KiB
C
/*
|
|
|
|
* Copyright (c) 2012-2017 The Khronos Group Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef _VX_KHR_TILING_H_
|
|
#define _VX_KHR_TILING_H_
|
|
|
|
/*!
|
|
* \file
|
|
* \brief The Khronos Extension for User Tiling Functions.
|
|
*
|
|
* \defgroup group_tiling Extension: User Tiling API
|
|
* \brief The Khronos Extension for User Tiling Functions.
|
|
*/
|
|
|
|
#define OPENVX_KHR_TILING "vx_khr_tiling"
|
|
|
|
#if defined(OPENVX_TILING_1_0)
|
|
#undef OPENVX_TILING_1_1
|
|
#endif
|
|
|
|
#include <VX/vx.h>
|
|
/* For vx_kernel_input_validate_f and vx_kernel_output_validate_f: */
|
|
#include <VX/vx_compatibility.h>
|
|
|
|
|
|
/*! \def VX_RESTRICT
|
|
* \brief A platform wrapper for the restrict keyword.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#if defined(_WIN32)
|
|
#define VX_RESTRICT
|
|
#else
|
|
#if defined(__cplusplus) || defined(ANDROID)
|
|
#define VX_RESTRICT __restrict
|
|
#elif defined(__linux__)
|
|
#define VX_RESTRICT
|
|
#elif defined __QNXNTO__
|
|
#define VX_RESTRICT
|
|
#else
|
|
#define VX_RESTRICT restrict
|
|
#endif
|
|
#endif
|
|
|
|
/*! \brief The User Tiling Function tile block size declaration.
|
|
* \details The author of a User Tiling Kernel will use this structure to define
|
|
* the dimensionality of the tile block.
|
|
* \ingroup group_tiling
|
|
*/
|
|
typedef struct _vx_tile_block_size_t {
|
|
vx_int32 width; /*!< \brief Tile block width in pixels. */
|
|
vx_int32 height; /*!< \brief Tile block height in pixels. */
|
|
} vx_tile_block_size_t;
|
|
|
|
/*! \brief The User Tiling Function Neighborhood declaration.
|
|
* \details The author of a User Tiling Kernel will use this structure to define
|
|
* the neighborhood surrounding the tile block.
|
|
* \ingroup group_tiling
|
|
*/
|
|
typedef struct _vx_neighborhood_size_t {
|
|
vx_int32 left; /*!< \brief Left of the tile block. */
|
|
vx_int32 right; /*!< \brief Right of the tile block. */
|
|
vx_int32 top; /*!< \brief Top of the tile block. */
|
|
vx_int32 bottom; /*!< \brief Bottom of the tile block. */
|
|
} vx_neighborhood_size_t;
|
|
|
|
/*! \brief A structure which describes the tile's parent image.
|
|
* \ingroup group_tiling
|
|
*/
|
|
typedef struct _vx_image_description_t {
|
|
vx_uint32 width; /*!< \brief Width of the image */
|
|
vx_uint32 height; /*!< \brief Height of the image */
|
|
vx_df_image format; /*!< \brief The <tt>\ref vx_df_image_e</tt> of the image */
|
|
vx_uint32 planes; /*!< \brief The number of planes in the image */
|
|
vx_enum range; /*!< \brief The <tt>\ref vx_channel_range_e</tt> enumeration. */
|
|
vx_enum space; /*!< \brief The <tt>\ref vx_color_space_e</tt> enumeration. */
|
|
} vx_image_description_t;
|
|
|
|
/*! \brief The maximum number of planes in a tiled image.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define VX_MAX_TILING_PLANES (4)
|
|
|
|
/*! \brief The tile structure declaration.
|
|
* \ingroup group_tiling
|
|
*/
|
|
typedef struct _vx_tile_t {
|
|
/*! \brief The array of pointers to the tile's image plane. */
|
|
vx_uint8 * VX_RESTRICT base[VX_MAX_TILING_PLANES];
|
|
/*! \brief The top left X pixel index within the width dimension of the image. */
|
|
vx_uint32 tile_x;
|
|
/*! \brief The top left Y pixel index within the height dimension of the image. */
|
|
vx_uint32 tile_y;
|
|
/*! \brief The array of addressing structure to describe each plane. */
|
|
vx_imagepatch_addressing_t addr[VX_MAX_TILING_PLANES];
|
|
/*! \brief The output block size structure. */
|
|
vx_tile_block_size_t tile_block;
|
|
/*! \brief The neighborhood definition. */
|
|
vx_neighborhood_size_t neighborhood;
|
|
/*! \brief The description and attributes of the image. */
|
|
vx_image_description_t image;
|
|
} vx_tile_t;
|
|
|
|
#ifndef VX_TILE_ATTRIBUTES_DEFINITIONS
|
|
|
|
/*!
|
|
* \brief The full height of the tile's parent image in pixels.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxImageHeight(ptile) ((ptile))->image.height)
|
|
|
|
/*!
|
|
* \brief The full width of the tile's parent image in pixels.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxImageWidth(ptile) ((ptile))->image.width)
|
|
|
|
/*!
|
|
* \brief The offset between the left edge of the image and the left edge of the tile, in pixels.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxTileX(ptile) ((ptile)->tile_x)
|
|
|
|
/*!
|
|
* \brief The offset between the top edge of the image and the top edge of the tile, in pixels.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxTileY(ptile) ((ptile)->tile_y)
|
|
|
|
/*!
|
|
* \brief The width of the tile in pixels.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \param [in] index The plane index.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxTileWidth(ptile, index) ((ptile)->addr[index].dim_x)
|
|
|
|
/*!
|
|
* \brief The height of the tile in pixels.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \param [in] index The plane index.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxTileHeight(ptile, index) ((ptile)->addr[index].dim_y)
|
|
|
|
/*!
|
|
* \brief The tile block height.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxTileBlockHeight(ptile) ((ptile)->tile_block.height)
|
|
|
|
/*!
|
|
* \brief The tile block width.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxTileBlockWidth(ptile) ((ptile)->tile_block.width)
|
|
|
|
/*!
|
|
* \brief The simple wrapper to access each image's neighborhood -X value.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxNeighborhoodLeft(ptile) ((ptile)->neighborhood.left)
|
|
|
|
/*!
|
|
* \brief The simple wrapper to access each image's neighborhood +X value.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxNeighborhoodRight(ptile) ((ptile)->neighborhood.right)
|
|
|
|
/*!
|
|
* \brief The simple wrapper to access each image's neighborhood -Y value.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxNeighborhoodTop(ptile) ((ptile)->neighborhood.top)
|
|
|
|
/*!
|
|
* \brief The simple wrapper to access each image's neighborhood +Y value.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxNeighborhoodBottom(ptile) ((ptile)->neighborhood.bottom)
|
|
|
|
|
|
#endif
|
|
|
|
/*! \brief The User Kernel Tiling Attributes.
|
|
* \ingroup group_tiling
|
|
*/
|
|
enum vx_kernel_attribute_tiling_e {
|
|
/*! \brief This allows a tiling mode kernel to set its input neighborhood. */
|
|
VX_KERNEL_INPUT_NEIGHBORHOOD = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x7,
|
|
/*! \brief This allows a tiling mode kernel to set its output tile block size. */
|
|
VX_KERNEL_OUTPUT_TILE_BLOCK_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x8,
|
|
/*! \brief This allows the author to set the border mode on the tiling kernel. */
|
|
VX_KERNEL_BORDER = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0x9,
|
|
/*! \brief This determines the per tile memory allocation. */
|
|
VX_KERNEL_TILE_MEMORY_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0xA,
|
|
#if defined(OPENVX_TILING_1_1)
|
|
/*! \brief This allows a tiling mode kernel to set its input tile block size. */
|
|
VX_KERNEL_INPUT_TILE_BLOCK_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0xB,
|
|
/*! \brief This allows a tiling mode kernel to set its output neighborhood. */
|
|
VX_KERNEL_OUTPUT_NEIGHBORHOOD = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_KERNEL) + 0xC,
|
|
#endif
|
|
};
|
|
|
|
/*! \brief The User Node Tiling Attributes.
|
|
* \note These are largely unusable by the tiling function, as it doesn't give you the node reference!
|
|
* \ingroup group_tiling
|
|
*/
|
|
enum vx_node_attribute_tiling_e {
|
|
/*! \brief This allows a tiling mode node to get its input neighborhood. */
|
|
VX_NODE_INPUT_NEIGHBORHOOD = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0xB,
|
|
/*! \brief This allows a tiling mode node to get its output tile block size. */
|
|
VX_NODE_OUTPUT_TILE_BLOCK_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0xC,
|
|
/*! \brief This is the size of the tile local memory area. */
|
|
VX_NODE_TILE_MEMORY_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0xD,
|
|
#if defined(OPENVX_TILING_1_1)
|
|
/*! \brief This allows a tiling mode node to get its input tile block size. */
|
|
VX_NODE_INPUT_TILE_BLOCK_SIZE = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0xE,
|
|
/*! \brief This allows a tiling mode node to get its output neighborhood. */
|
|
VX_NODE_OUTPUT_NEIGHBORHOOD = VX_ATTRIBUTE_BASE(VX_ID_KHRONOS, VX_TYPE_NODE) + 0xF,
|
|
#endif
|
|
};
|
|
|
|
/*! \brief The tiling border mode extensions
|
|
* \ingroup group_tiling
|
|
*/
|
|
enum vx_border_tiling_e {
|
|
/*! \brief This value indicates that the author of the tiling kernel wrote
|
|
* code to handle border conditions into the kernel itself. If this mode
|
|
* is set, it can not be overriden by a call to the \ref vxSetNodeAttribute
|
|
* with \ref VX_NODE_BORDER.
|
|
*/
|
|
VX_BORDER_MODE_SELF = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_BORDER) + 0x3,
|
|
};
|
|
|
|
/*! \typedef vx_tiling_kernel_f
|
|
* \brief Tiling Kernel function typedef for User Tiling Kernels.
|
|
* \note Tiles may come in any dimension and are not guaranteed to be delivered in
|
|
* any particular order.
|
|
* \param [in] parameters The array abstract pointers to parameters.
|
|
* \param [in] tile_memory The local tile memory pointer if requested, otherwise NULL.
|
|
* \param [in] tile_memory_size The size of the local tile memory, if not requested, 0.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#ifdef __cplusplus
|
|
typedef void (*vx_tiling_kernel_f)(void * VX_RESTRICT parameters[],
|
|
void * VX_RESTRICT tile_memory,
|
|
vx_size tile_memory_size);
|
|
#else
|
|
typedef void (*vx_tiling_kernel_f)(void * VX_RESTRICT parameters[VX_RESTRICT],
|
|
void * VX_RESTRICT tile_memory,
|
|
vx_size tile_memory_size);
|
|
#endif
|
|
|
|
#ifndef VX_IMAGE_PIXEL_DEFINITION
|
|
|
|
/*! \def vxImageOffset
|
|
* \brief Computes the offset within an image.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \param [in] i The plane index.
|
|
* \param [in] x The Width Coordinates.
|
|
* \param [in] y The Height Coordinates.
|
|
* \param [in] ox The X offset.
|
|
* \param [in] oy The Y offset.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxImageOffset(ptile, i, x, y, ox, oy) \
|
|
((ptile)->addr[i].stride_y * (vx_int32)(((vx_int32)((oy)+(y)) * (vx_int32)(ptile)->addr[i].scale_y)/(vx_int32)VX_SCALE_UNITY)) + \
|
|
((ptile)->addr[i].stride_x * (vx_int32)(((vx_int32)((ox)+(x)) * (vx_int32)(ptile)->addr[i].scale_x)/(vx_int32)VX_SCALE_UNITY))
|
|
|
|
|
|
/*! \def vxImagePixel
|
|
* \brief Accesses an image pixel as a type-cast indexed pointer dereference.
|
|
* \param [in] type The type of the image pixel. Example values are <tt>\ref vx_uint8</tt>, <tt>\ref vx_uint16</tt>, <tt>\ref vx_uint32</tt>, etc.
|
|
* \param [in] ptile The pointer to the \ref vx_tile_t structure.
|
|
* \param [in] i The plane index.
|
|
* \param [in] x The Center Pixel in Width Coordinates.
|
|
* \param [in] y The Center Pixel in Height Coordinates.
|
|
* \param [in] ox The X offset.
|
|
* \param [in] oy The Y offset.
|
|
* \ingroup group_tiling
|
|
*/
|
|
#define vxImagePixel(type, ptile, i, x, y, ox, oy) \
|
|
*((type *)(&((vx_uint8 *)(ptile)->base[i])[vxImageOffset(ptile, i, x, y, ox, oy)]))
|
|
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*! \brief Allows a user to add a tile-able kernel to the OpenVX system.
|
|
* \param [in] context The handle to the implementation context.
|
|
* \param [in] name The string to be used to match the kernel.
|
|
* \param [in] enumeration The enumerated value of the kernel to be used by clients.
|
|
* \param [in] flexible_func_ptr The process-local flexible function pointer to be invoked.
|
|
* \param [in] fast_func_ptr The process-local fast function pointer to be invoked.
|
|
* \param [in] num_params The number of parameters for this kernel.
|
|
* \param [in] input The pointer to a function which will validate the
|
|
* input parameters to this kernel.
|
|
* \param [in] output The pointer to a function which will validate the
|
|
* output parameters to this kernel.
|
|
* \note Tiling Kernels do not have access to any of the normal node attributes listed
|
|
* in \ref vx_node_attribute_e.
|
|
* \post Call <tt>\ref vxAddParameterToKernel</tt> for as many parameters as the function has,
|
|
* then call <tt>\ref vxFinalizeKernel</tt>.
|
|
* \retval 0 Indicates that an error occurred when adding the kernel.
|
|
* Note that the fast or flexible formula, but not both, can be NULL.
|
|
* \ingroup group_tiling
|
|
*/
|
|
VX_API_ENTRY vx_kernel VX_API_CALL vxAddTilingKernel(vx_context context,
|
|
vx_char name[VX_MAX_KERNEL_NAME],
|
|
vx_enum enumeration,
|
|
vx_tiling_kernel_f flexible_func_ptr,
|
|
vx_tiling_kernel_f fast_func_ptr,
|
|
vx_uint32 num_params,
|
|
vx_kernel_input_validate_f input,
|
|
vx_kernel_output_validate_f output);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|