| /* |
| |
| * Copyright (c) 2016-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. |
| */ |
| |
| #if defined OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION |
| |
| #include <math.h> |
| #include <string.h> |
| #include <float.h> |
| #include <VX/vx.h> |
| |
| #include "test_engine/test.h" |
| |
| TESTCASE(Scalar, CT_VXContext, ct_setup_vx_context, 0) |
| |
| typedef union |
| { |
| vx_char chr; |
| vx_int8 s08; |
| vx_uint8 u08; |
| vx_int16 s16; |
| vx_uint16 u16; |
| vx_int32 s32; |
| vx_uint32 u32; |
| vx_int64 s64; |
| vx_uint64 u64; |
| vx_float32 f32; |
| vx_float64 f64; |
| vx_enum enm; |
| vx_size size; |
| vx_df_image fcc; |
| vx_bool boolean; |
| vx_uint8 data[8]; |
| |
| /* support type of scalar with size */ |
| vx_rectangle_t rect; |
| vx_keypoint_t key_point; |
| vx_coordinates2d_t coord2d; |
| vx_coordinates3d_t coord3d; |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| vx_coordinates2df_t coord2df; |
| vx_hog_t hog; |
| vx_hough_lines_p_t houghlines; |
| vx_line2d_t line2d; |
| vx_tensor_matrix_multiply_params_t matrix; |
| #endif |
| } scalar_val; |
| |
| typedef struct |
| { |
| const char* name; |
| vx_enum data_type; |
| } format_arg; |
| |
| static void own_init_scalar_value(vx_enum type, scalar_val* val, vx_bool variant) |
| { |
| switch (type) |
| { |
| case VX_TYPE_CHAR: val->chr = variant == vx_true_e ? 1 : 2; break; |
| case VX_TYPE_INT8: val->s08 = variant == vx_true_e ? 2 : 3; break; |
| case VX_TYPE_UINT8: val->u08 = variant == vx_true_e ? 3 : 4; break; |
| case VX_TYPE_INT16: val->s16 = variant == vx_true_e ? 4 : 5; break; |
| case VX_TYPE_UINT16: val->u16 = variant == vx_true_e ? 5 : 6; break; |
| case VX_TYPE_INT32: val->s32 = variant == vx_true_e ? 6 : 7; break; |
| case VX_TYPE_UINT32: val->u32 = variant == vx_true_e ? 7 : 8; break; |
| case VX_TYPE_INT64: val->s64 = variant == vx_true_e ? 8 : 9; break; |
| case VX_TYPE_UINT64: val->u64 = variant == vx_true_e ? 9 : 10; break; |
| case VX_TYPE_FLOAT32: val->f32 = variant == vx_true_e ? 1.5f : 9.9f; break; |
| case VX_TYPE_FLOAT64: val->f64 = variant == vx_true_e ? 1.5 : 9.9; break; |
| case VX_TYPE_ENUM: val->enm = variant == vx_true_e ? VX_BORDER_CONSTANT : VX_BORDER_REPLICATE; break; |
| case VX_TYPE_SIZE: val->size = variant == vx_true_e ? 10 : 999; break; |
| case VX_TYPE_DF_IMAGE: val->fcc = variant == vx_true_e ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_U8; break; |
| case VX_TYPE_BOOL: val->boolean = variant == vx_true_e ? vx_true_e : vx_false_e; break; |
| |
| /* support type of scalar with size */ |
| case VX_TYPE_RECTANGLE: |
| if (variant == vx_true_e) |
| { |
| val->rect.start_x = 0; |
| val->rect.start_y = 0; |
| val->rect.end_x = 1280; |
| val->rect.end_y = 720; |
| } |
| break; |
| case VX_TYPE_KEYPOINT: |
| if (variant == vx_true_e) |
| { |
| val->key_point.x = 128; |
| val->key_point.y = 256; |
| val->key_point.strength = 20.0; |
| val->key_point.scale = 0.8; |
| val->key_point.orientation = 0.3; |
| val->key_point.tracking_status = 1; |
| val->key_point.error = 0; |
| } |
| break; |
| case VX_TYPE_COORDINATES2D: |
| if (variant == vx_true_e) |
| { |
| val->coord2d.x = 10; |
| val->coord2d.y = 9; |
| } |
| break; |
| case VX_TYPE_COORDINATES3D: |
| if (variant == vx_true_e) |
| { |
| val->coord3d.x = 16; |
| val->coord3d.y = 31; |
| val->coord3d.z = 22; |
| } |
| break; |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| case VX_TYPE_COORDINATES2DF: |
| if (variant == vx_true_e) |
| { |
| val->coord2df.x = 2.7f; |
| val->coord2df.y = 3.5f; |
| } |
| break; |
| case VX_TYPE_HOG_PARAMS: |
| if (variant == vx_true_e) |
| { |
| val->hog.cell_width = 16; |
| val->hog.cell_height = 16; |
| val->hog.block_width = 128; |
| val->hog.block_height = 128; |
| val->hog.block_stride = 1280; |
| val->hog.num_bins = 5; |
| val->hog.window_width = 1280; |
| val->hog.window_height = 720; |
| val->hog.window_stride = 1280; |
| val->hog.threshold = 0.2f; |
| } |
| break; |
| case VX_TYPE_HOUGH_LINES_PARAMS: |
| if (variant == vx_true_e) |
| { |
| val->houghlines.rho = 0.8f; |
| val->houghlines.theta = 0.5f; |
| val->houghlines.threshold = 235; |
| val->houghlines.line_length = 8; |
| val->houghlines.line_gap = 3; |
| val->houghlines.theta_max = 1.2f; |
| val->houghlines.theta_min = 0.1f; |
| } |
| break; |
| case VX_TYPE_LINE_2D: |
| if (variant == vx_true_e) |
| { |
| val->line2d.start_x = 2.3f; |
| val->line2d.start_y = 1.5f; |
| val->line2d.end_x = 1279.9f; |
| val->line2d.end_y = 718.8f; |
| } |
| break; |
| case VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS: |
| if (variant == vx_true_e) |
| { |
| val->matrix.transpose_input1 = vx_true_e; |
| val->matrix.transpose_input2 = vx_false_e; |
| val->matrix.transpose_input3 = vx_true_e; |
| } |
| break; |
| #endif |
| default: |
| FAIL("Unsupported type: (%.4s)", &type); |
| } |
| return; |
| } |
| |
| static vx_size ownGetSizeByType(vx_enum type) |
| { |
| vx_size size = 0; |
| switch (type) |
| { |
| case VX_TYPE_CHAR: size = sizeof(vx_char); break; |
| case VX_TYPE_INT8: size = sizeof(vx_int8); break; |
| case VX_TYPE_UINT8: size = sizeof(vx_uint8); break; |
| case VX_TYPE_INT16: size = sizeof(vx_int16); break; |
| case VX_TYPE_UINT16: size = sizeof(vx_uint16); break; |
| case VX_TYPE_INT32: size = sizeof(vx_int32); break; |
| case VX_TYPE_UINT32: size = sizeof(vx_uint32); break; |
| case VX_TYPE_INT64: size = sizeof(vx_int64); break; |
| case VX_TYPE_UINT64: size = sizeof(vx_uint64); break; |
| case VX_TYPE_FLOAT32: size = sizeof(vx_float32); break; |
| case VX_TYPE_FLOAT64: size = sizeof(vx_float64); break; |
| case VX_TYPE_ENUM: size = sizeof(vx_int32); break; |
| case VX_TYPE_SIZE: size = sizeof(vx_size); break; |
| case VX_TYPE_DF_IMAGE: size = sizeof(vx_df_image); break; |
| case VX_TYPE_BOOL: size = sizeof(vx_bool); break; |
| |
| /* support type of scalar with size */ |
| case VX_TYPE_RECTANGLE: |
| size = sizeof(vx_rectangle_t); |
| break; |
| case VX_TYPE_KEYPOINT: |
| size = sizeof(vx_keypoint_t); |
| break; |
| case VX_TYPE_COORDINATES2D: |
| size = sizeof(vx_coordinates2d_t); |
| break; |
| case VX_TYPE_COORDINATES3D: |
| size = sizeof(vx_coordinates3d_t); |
| break; |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| case VX_TYPE_COORDINATES2DF: |
| size = sizeof(vx_coordinates2df_t); |
| break; |
| case VX_TYPE_HOG_PARAMS: |
| size = sizeof(vx_hog_t); |
| break; |
| case VX_TYPE_HOUGH_LINES_PARAMS: |
| size = sizeof(vx_hough_lines_p_t); |
| break; |
| case VX_TYPE_LINE_2D: |
| size = sizeof(vx_line2d_t); |
| break; |
| case VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS: |
| size = sizeof(vx_tensor_matrix_multiply_params_t); |
| break; |
| #endif |
| default: |
| CT_RecordFailureAtFormat("Unsupported type: (%.4s)", __FUNCTION__, __FILE__, __LINE__, &type); |
| break; |
| } |
| return size; |
| } |
| |
| static void ownCheckScalarVal(vx_enum type, scalar_val *actual_val, scalar_val *expect_val) |
| { |
| switch (type) |
| { |
| case VX_TYPE_CHAR: |
| ASSERT_EQ_INT(actual_val->chr, expect_val->chr); |
| break; |
| |
| case VX_TYPE_INT8: |
| ASSERT_EQ_INT(actual_val->s08, expect_val->s08); |
| break; |
| |
| case VX_TYPE_UINT8: |
| ASSERT_EQ_INT(actual_val->u08, expect_val->u08); |
| break; |
| |
| case VX_TYPE_INT16: |
| ASSERT_EQ_INT(actual_val->s16, expect_val->s16); |
| break; |
| |
| case VX_TYPE_UINT16: |
| ASSERT_EQ_INT(actual_val->u16, expect_val->u16); |
| break; |
| |
| case VX_TYPE_INT32: |
| ASSERT_EQ_INT(actual_val->s32, expect_val->s32); |
| break; |
| |
| case VX_TYPE_UINT32: |
| ASSERT_EQ_INT(actual_val->u32, expect_val->u32); |
| break; |
| |
| case VX_TYPE_INT64: |
| ASSERT_EQ_INT(actual_val->s64, expect_val->s64); |
| break; |
| |
| case VX_TYPE_UINT64: |
| ASSERT_EQ_INT(actual_val->u64, expect_val->u64); |
| break; |
| |
| case VX_TYPE_FLOAT32: |
| ASSERT(fabs(actual_val->f32 - expect_val->f32) < 0.000001f); |
| break; |
| |
| case VX_TYPE_FLOAT64: |
| ASSERT(fabs(actual_val->f64 - expect_val->f64) < 0.000001f); |
| break; |
| |
| case VX_TYPE_DF_IMAGE: |
| ASSERT_EQ_INT(actual_val->fcc, expect_val->fcc); |
| break; |
| |
| case VX_TYPE_ENUM: |
| ASSERT_EQ_INT(actual_val->enm, expect_val->enm); |
| break; |
| |
| case VX_TYPE_SIZE: |
| ASSERT_EQ_INT(actual_val->size, expect_val->size); |
| break; |
| |
| case VX_TYPE_BOOL: |
| ASSERT_EQ_INT(actual_val->boolean, expect_val->boolean); |
| break; |
| |
| case VX_TYPE_RECTANGLE: |
| ASSERT_EQ_INT(memcmp(&actual_val->rect, &expect_val->rect, sizeof(VX_TYPE_RECTANGLE)), 0); |
| break; |
| |
| case VX_TYPE_KEYPOINT: |
| ASSERT_EQ_INT(memcmp(&actual_val->key_point, &expect_val->key_point, sizeof(VX_TYPE_KEYPOINT)), 0); |
| break; |
| |
| case VX_TYPE_COORDINATES2D: |
| ASSERT_EQ_INT(memcmp(&actual_val->coord2d, &expect_val->coord2d, sizeof(VX_TYPE_COORDINATES2D)), 0); |
| break; |
| |
| case VX_TYPE_COORDINATES3D: |
| ASSERT_EQ_INT(memcmp(&actual_val->coord3d, &expect_val->coord3d, sizeof(VX_TYPE_COORDINATES3D)), 0); |
| break; |
| |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| case VX_TYPE_COORDINATES2DF: |
| ASSERT_EQ_INT(memcmp(&actual_val->coord2df, &expect_val->coord2df, sizeof(VX_TYPE_COORDINATES2DF)), 0); |
| break; |
| |
| case VX_TYPE_HOG_PARAMS: |
| ASSERT_EQ_INT(memcmp(&actual_val->hog, &expect_val->hog, sizeof(VX_TYPE_HOG_PARAMS)), 0); |
| break; |
| |
| case VX_TYPE_HOUGH_LINES_PARAMS: |
| ASSERT_EQ_INT(memcmp(&actual_val->houghlines, &expect_val->houghlines, sizeof(VX_TYPE_HOUGH_LINES_PARAMS)), 0); |
| break; |
| |
| case VX_TYPE_LINE_2D: |
| ASSERT_EQ_INT(memcmp(&actual_val->line2d, &expect_val->line2d, sizeof(VX_TYPE_LINE_2D)), 0); |
| break; |
| |
| case VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS: |
| ASSERT_EQ_INT(memcmp(&actual_val->matrix, &expect_val->matrix, sizeof(VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS)), 0); |
| break; |
| #endif |
| default: |
| FAIL("Unsupported type: (%.4s)", &type); |
| break; |
| } |
| return; |
| } |
| |
| TEST_WITH_ARG(Scalar, testCreateScalar, format_arg, |
| ARG_ENUM(VX_TYPE_CHAR), |
| ARG_ENUM(VX_TYPE_INT8), |
| ARG_ENUM(VX_TYPE_UINT8), |
| ARG_ENUM(VX_TYPE_INT16), |
| ARG_ENUM(VX_TYPE_UINT16), |
| ARG_ENUM(VX_TYPE_INT32), |
| ARG_ENUM(VX_TYPE_UINT32), |
| ARG_ENUM(VX_TYPE_INT64), |
| ARG_ENUM(VX_TYPE_UINT64), |
| ARG_ENUM(VX_TYPE_FLOAT32), |
| ARG_ENUM(VX_TYPE_FLOAT64), |
| ARG_ENUM(VX_TYPE_ENUM), |
| ARG_ENUM(VX_TYPE_SIZE), |
| ARG_ENUM(VX_TYPE_DF_IMAGE), |
| ARG_ENUM(VX_TYPE_BOOL) |
| ) |
| { |
| vx_context context = context_->vx_context_; |
| vx_scalar scalar = 0; |
| vx_enum ref_type = arg_->data_type; |
| scalar_val ref; |
| |
| own_init_scalar_value(ref_type, &ref, vx_true_e); |
| |
| ASSERT_VX_OBJECT(scalar = vxCreateScalar(context, ref_type, &ref), VX_TYPE_SCALAR); |
| |
| VX_CALL(vxReleaseScalar(&scalar)); |
| |
| ASSERT(scalar == 0); |
| |
| return; |
| } /* testCreateScalar() */ |
| |
| TEST_WITH_ARG(Scalar, testQueryScalar, format_arg, |
| ARG_ENUM(VX_TYPE_CHAR), |
| ARG_ENUM(VX_TYPE_INT8), |
| ARG_ENUM(VX_TYPE_UINT8), |
| ARG_ENUM(VX_TYPE_INT16), |
| ARG_ENUM(VX_TYPE_UINT16), |
| ARG_ENUM(VX_TYPE_INT32), |
| ARG_ENUM(VX_TYPE_UINT32), |
| ARG_ENUM(VX_TYPE_INT64), |
| ARG_ENUM(VX_TYPE_UINT64), |
| ARG_ENUM(VX_TYPE_FLOAT32), |
| ARG_ENUM(VX_TYPE_FLOAT64), |
| ARG_ENUM(VX_TYPE_ENUM), |
| ARG_ENUM(VX_TYPE_SIZE), |
| ARG_ENUM(VX_TYPE_DF_IMAGE), |
| ARG_ENUM(VX_TYPE_BOOL) |
| ) |
| { |
| vx_context context = context_->vx_context_; |
| vx_scalar scalar = 0; |
| vx_enum ref_type = arg_->data_type; |
| vx_enum tst_type = 0; |
| scalar_val ref; |
| |
| own_init_scalar_value(ref_type, &ref, vx_true_e); |
| |
| ASSERT_VX_OBJECT(scalar = vxCreateScalar(context, ref_type, &ref), VX_TYPE_SCALAR); |
| |
| VX_CALL(vxQueryScalar(scalar, VX_SCALAR_TYPE, &tst_type, sizeof(tst_type))); |
| ASSERT_EQ_INT(ref_type, tst_type); |
| |
| VX_CALL(vxReleaseScalar(&scalar)); |
| |
| ASSERT(scalar == 0); |
| |
| return; |
| } /* testQueryScalar() */ |
| |
| TEST_WITH_ARG(Scalar, testCopyScalar, format_arg, |
| ARG_ENUM(VX_TYPE_CHAR), |
| ARG_ENUM(VX_TYPE_INT8), |
| ARG_ENUM(VX_TYPE_UINT8), |
| ARG_ENUM(VX_TYPE_INT16), |
| ARG_ENUM(VX_TYPE_UINT16), |
| ARG_ENUM(VX_TYPE_INT32), |
| ARG_ENUM(VX_TYPE_UINT32), |
| ARG_ENUM(VX_TYPE_INT64), |
| ARG_ENUM(VX_TYPE_UINT64), |
| ARG_ENUM(VX_TYPE_FLOAT32), |
| ARG_ENUM(VX_TYPE_FLOAT64), |
| ARG_ENUM(VX_TYPE_ENUM), |
| ARG_ENUM(VX_TYPE_SIZE), |
| ARG_ENUM(VX_TYPE_DF_IMAGE), |
| ARG_ENUM(VX_TYPE_BOOL) |
| ) |
| { |
| vx_context context = context_->vx_context_; |
| vx_scalar scalar = 0; |
| vx_enum type = arg_->data_type; |
| scalar_val val1; |
| scalar_val val2; |
| scalar_val tst; |
| |
| own_init_scalar_value(type, &val1, vx_true_e); |
| own_init_scalar_value(type, &val2, vx_false_e); |
| |
| ASSERT_VX_OBJECT(scalar = vxCreateScalar(context, type, &val1), VX_TYPE_SCALAR); |
| |
| VX_CALL(vxCopyScalar(scalar, &tst, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); |
| |
| switch (type) |
| { |
| case VX_TYPE_CHAR: |
| ASSERT_EQ_INT(val1.chr, tst.chr); |
| break; |
| |
| case VX_TYPE_INT8: |
| ASSERT_EQ_INT(val1.s08, tst.s08); |
| break; |
| |
| case VX_TYPE_UINT8: |
| ASSERT_EQ_INT(val1.u08, tst.u08); |
| break; |
| |
| case VX_TYPE_INT16: |
| ASSERT_EQ_INT(val1.s16, tst.s16); |
| break; |
| |
| case VX_TYPE_UINT16: |
| ASSERT_EQ_INT(val1.u16, tst.u16); |
| break; |
| |
| case VX_TYPE_INT32: |
| ASSERT_EQ_INT(val1.s32, tst.s32); |
| break; |
| |
| case VX_TYPE_UINT32: |
| ASSERT_EQ_INT(val1.u32, tst.u32); |
| break; |
| |
| case VX_TYPE_INT64: |
| ASSERT_EQ_INT(val1.s64, tst.s64); |
| break; |
| |
| case VX_TYPE_UINT64: |
| ASSERT_EQ_INT(val1.u64, tst.u64); |
| break; |
| |
| case VX_TYPE_FLOAT32: |
| ASSERT(fabs(val1.f32 - tst.f32) < 0.000001f); |
| break; |
| |
| case VX_TYPE_FLOAT64: |
| ASSERT(fabs(val1.f64 - tst.f64) < 0.000001f); |
| break; |
| |
| case VX_TYPE_DF_IMAGE: |
| ASSERT_EQ_INT(val1.fcc, tst.fcc); |
| break; |
| |
| case VX_TYPE_ENUM: |
| ASSERT_EQ_INT(val1.enm, tst.enm); |
| break; |
| |
| case VX_TYPE_SIZE: |
| ASSERT_EQ_INT(val1.size, tst.size); |
| break; |
| |
| case VX_TYPE_BOOL: |
| ASSERT_EQ_INT(val1.boolean, tst.boolean); |
| break; |
| |
| default: |
| FAIL("Unsupported type: (%.4s)", &type); |
| break; |
| } |
| |
| /* change scalar value */ |
| VX_CALL(vxCopyScalar(scalar, &val2, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); |
| |
| /* read value back */ |
| VX_CALL(vxCopyScalar(scalar, &tst, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); |
| |
| switch (type) |
| { |
| case VX_TYPE_CHAR: |
| ASSERT_EQ_INT(val2.chr, tst.chr); |
| break; |
| |
| case VX_TYPE_INT8: |
| ASSERT_EQ_INT(val2.s08, tst.s08); |
| break; |
| |
| case VX_TYPE_UINT8: |
| ASSERT_EQ_INT(val2.u08, tst.u08); |
| break; |
| |
| case VX_TYPE_INT16: |
| ASSERT_EQ_INT(val2.s16, tst.s16); |
| break; |
| |
| case VX_TYPE_UINT16: |
| ASSERT_EQ_INT(val2.u16, tst.u16); |
| break; |
| |
| case VX_TYPE_INT32: |
| ASSERT_EQ_INT(val2.s32, tst.s32); |
| break; |
| |
| case VX_TYPE_UINT32: |
| ASSERT_EQ_INT(val2.u32, tst.u32); |
| break; |
| |
| case VX_TYPE_INT64: |
| ASSERT_EQ_INT(val2.s64, tst.s64); |
| break; |
| |
| case VX_TYPE_UINT64: |
| ASSERT_EQ_INT(val2.u64, tst.u64); |
| break; |
| |
| case VX_TYPE_FLOAT32: |
| ASSERT(fabs(val2.f32 - tst.f32) < 0.000001f); |
| break; |
| |
| case VX_TYPE_FLOAT64: |
| ASSERT(fabs(val2.f64 - tst.f64) < 0.000001f); |
| break; |
| |
| case VX_TYPE_DF_IMAGE: |
| ASSERT_EQ_INT(val2.fcc, tst.fcc); |
| break; |
| |
| case VX_TYPE_ENUM: |
| ASSERT_EQ_INT(val2.enm, tst.enm); |
| break; |
| |
| case VX_TYPE_SIZE: |
| ASSERT_EQ_INT(val2.size, tst.size); |
| break; |
| |
| case VX_TYPE_BOOL: |
| ASSERT_EQ_INT(val2.boolean, tst.boolean); |
| break; |
| |
| default: |
| FAIL("Unsupported type: (%.4s)", &type); |
| break; |
| } |
| |
| VX_CALL(vxReleaseScalar(&scalar)); |
| |
| ASSERT(scalar == 0); |
| |
| return; |
| } /* testCopyScalar() */ |
| |
| TEST_WITH_ARG(Scalar, testCreateScalarWithSize, format_arg, |
| ARG_ENUM(VX_TYPE_CHAR), |
| ARG_ENUM(VX_TYPE_INT8), |
| ARG_ENUM(VX_TYPE_UINT8), |
| ARG_ENUM(VX_TYPE_INT16), |
| ARG_ENUM(VX_TYPE_UINT16), |
| ARG_ENUM(VX_TYPE_INT32), |
| ARG_ENUM(VX_TYPE_UINT32), |
| ARG_ENUM(VX_TYPE_INT64), |
| ARG_ENUM(VX_TYPE_UINT64), |
| ARG_ENUM(VX_TYPE_FLOAT32), |
| ARG_ENUM(VX_TYPE_FLOAT64), |
| ARG_ENUM(VX_TYPE_ENUM), |
| ARG_ENUM(VX_TYPE_SIZE), |
| ARG_ENUM(VX_TYPE_DF_IMAGE), |
| ARG_ENUM(VX_TYPE_BOOL), |
| ARG_ENUM(VX_TYPE_RECTANGLE), |
| ARG_ENUM(VX_TYPE_KEYPOINT), |
| ARG_ENUM(VX_TYPE_COORDINATES2D), |
| ARG_ENUM(VX_TYPE_COORDINATES3D), |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| ARG_ENUM(VX_TYPE_COORDINATES2DF), |
| ARG_ENUM(VX_TYPE_HOG_PARAMS), |
| ARG_ENUM(VX_TYPE_HOUGH_LINES_PARAMS), |
| ARG_ENUM(VX_TYPE_LINE_2D), |
| ARG_ENUM(VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS) |
| #endif |
| ) |
| { |
| vx_context context = context_->vx_context_; |
| vx_scalar scalar = 0; |
| vx_enum ref_type = arg_->data_type; |
| scalar_val ref; |
| vx_size ref_size = ownGetSizeByType(ref_type); |
| |
| own_init_scalar_value(ref_type, &ref, vx_true_e); |
| |
| ASSERT_VX_OBJECT(scalar = vxCreateScalarWithSize(context, ref_type, &ref, ref_size), VX_TYPE_SCALAR); |
| |
| VX_CALL(vxReleaseScalar(&scalar)); |
| |
| ASSERT(scalar == 0); |
| |
| return; |
| } |
| |
| TEST_WITH_ARG(Scalar, testCopyScalarWithSize, format_arg, |
| ARG_ENUM(VX_TYPE_CHAR), |
| ARG_ENUM(VX_TYPE_INT8), |
| ARG_ENUM(VX_TYPE_UINT8), |
| ARG_ENUM(VX_TYPE_INT16), |
| ARG_ENUM(VX_TYPE_UINT16), |
| ARG_ENUM(VX_TYPE_INT32), |
| ARG_ENUM(VX_TYPE_UINT32), |
| ARG_ENUM(VX_TYPE_INT64), |
| ARG_ENUM(VX_TYPE_UINT64), |
| ARG_ENUM(VX_TYPE_FLOAT32), |
| ARG_ENUM(VX_TYPE_FLOAT64), |
| ARG_ENUM(VX_TYPE_ENUM), |
| ARG_ENUM(VX_TYPE_SIZE), |
| ARG_ENUM(VX_TYPE_DF_IMAGE), |
| ARG_ENUM(VX_TYPE_BOOL), |
| ARG_ENUM(VX_TYPE_RECTANGLE), |
| ARG_ENUM(VX_TYPE_KEYPOINT), |
| ARG_ENUM(VX_TYPE_COORDINATES2D), |
| ARG_ENUM(VX_TYPE_COORDINATES3D), |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| ARG_ENUM(VX_TYPE_COORDINATES2DF), |
| ARG_ENUM(VX_TYPE_HOG_PARAMS), |
| ARG_ENUM(VX_TYPE_HOUGH_LINES_PARAMS), |
| ARG_ENUM(VX_TYPE_LINE_2D), |
| ARG_ENUM(VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS) |
| #endif |
| ) |
| { |
| vx_context context = context_->vx_context_; |
| vx_scalar scalar = 0; |
| vx_enum ref_type = arg_->data_type; |
| scalar_val ref; |
| vx_size ref_size = ownGetSizeByType(ref_type); |
| scalar_val expect_ref; |
| scalar_val actual_ref; |
| |
| own_init_scalar_value(ref_type, &ref, vx_true_e); |
| |
| ASSERT_VX_OBJECT(scalar = vxCreateScalarWithSize(context, ref_type, &ref, ref_size), VX_TYPE_SCALAR); |
| |
| //check result |
| VX_CALL(vxCopyScalarWithSize(scalar, ref_size, &expect_ref, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); |
| ownCheckScalarVal(ref_type, &ref, &expect_ref); |
| |
| own_init_scalar_value(ref_type, &actual_ref, vx_false_e); |
| VX_CALL(vxCopyScalarWithSize(scalar, ref_size, &actual_ref, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); |
| VX_CALL(vxCopyScalarWithSize(scalar, ref_size, &expect_ref, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); |
| ownCheckScalarVal(ref_type, &actual_ref, &expect_ref); |
| |
| VX_CALL(vxReleaseScalar(&scalar)); |
| |
| ASSERT(scalar == 0); |
| |
| return; |
| } |
| |
| TEST_WITH_ARG(Scalar, testCreateVirtualScalar, format_arg, |
| ARG_ENUM(VX_TYPE_CHAR), |
| ARG_ENUM(VX_TYPE_INT8), |
| ARG_ENUM(VX_TYPE_UINT8), |
| ARG_ENUM(VX_TYPE_INT16), |
| ARG_ENUM(VX_TYPE_UINT16), |
| ARG_ENUM(VX_TYPE_INT32), |
| ARG_ENUM(VX_TYPE_UINT32), |
| ARG_ENUM(VX_TYPE_INT64), |
| ARG_ENUM(VX_TYPE_UINT64), |
| ARG_ENUM(VX_TYPE_FLOAT32), |
| ARG_ENUM(VX_TYPE_FLOAT64), |
| ARG_ENUM(VX_TYPE_ENUM), |
| ARG_ENUM(VX_TYPE_SIZE), |
| ARG_ENUM(VX_TYPE_DF_IMAGE), |
| ARG_ENUM(VX_TYPE_BOOL), |
| ARG_ENUM(VX_TYPE_RECTANGLE), |
| ARG_ENUM(VX_TYPE_KEYPOINT), |
| ARG_ENUM(VX_TYPE_COORDINATES2D), |
| ARG_ENUM(VX_TYPE_COORDINATES3D), |
| #ifdef OPENVX_USE_ENHANCED_VISION |
| ARG_ENUM(VX_TYPE_COORDINATES2DF), |
| ARG_ENUM(VX_TYPE_HOG_PARAMS), |
| ARG_ENUM(VX_TYPE_HOUGH_LINES_PARAMS), |
| ARG_ENUM(VX_TYPE_LINE_2D), |
| ARG_ENUM(VX_TYPE_TENSOR_MATRIX_MULTIPLY_PARAMS) |
| #endif |
| ) |
| { |
| vx_context context = context_->vx_context_; |
| vx_scalar scalar = 0; |
| vx_enum ref_type = arg_->data_type; |
| vx_graph graph = 0; |
| vx_enum expect_type = VX_TYPE_INVALID; |
| |
| ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH); |
| ASSERT_VX_OBJECT(scalar = vxCreateVirtualScalar(graph, ref_type), VX_TYPE_SCALAR); |
| |
| VX_CALL(vxQueryScalar(scalar, VX_SCALAR_TYPE, &expect_type, sizeof(vx_enum))); |
| EXPECT_EQ_INT(expect_type, ref_type); |
| |
| VX_CALL(vxReleaseScalar(&scalar)); |
| ASSERT(scalar == 0); |
| |
| VX_CALL(vxReleaseGraph(&graph)); |
| ASSERT(graph == 0); |
| |
| return; |
| } |
| |
| TESTCASE_TESTS(Scalar, |
| testCreateScalar, |
| testQueryScalar, |
| testCopyScalar, |
| testCreateScalarWithSize, |
| testCopyScalarWithSize, |
| testCreateVirtualScalar |
| ) |
| |
| #endif //OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION |
