From 57b3ab2f977ba59e521e70f6e01d1ab40be02807 Mon Sep 17 00:00:00 2001 From: Jaeyun Date: Thu, 6 Dec 2018 19:12:13 +0900 Subject: [PATCH] [Test] add more testcases Using gst-harness, add testcases for the property acceleration in tensor-transform. Signed-off-by: Jaeyun Jung --- tests/nnstreamer_plugins/unittest_plugins.cpp | 1293 ++++++++++++++++++++++++- 1 file changed, 1269 insertions(+), 24 deletions(-) diff --git a/tests/nnstreamer_plugins/unittest_plugins.cpp b/tests/nnstreamer_plugins/unittest_plugins.cpp index 92fc699..8b92a18 100644 --- a/tests/nnstreamer_plugins/unittest_plugins.cpp +++ b/tests/nnstreamer_plugins/unittest_plugins.cpp @@ -46,6 +46,80 @@ TEST (test_tensor_transform, typecast_1) h = gst_harness_new ("tensor_transform"); g_object_set (h->element, "mode", "typecast", "option", "uint32", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_UINT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint8_t value = (i + 1) * (b + 1); + ((uint8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + uint32_t expected = (i + 1) * (b + 1); + EXPECT_EQ (((uint32_t *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, uint8 > uint32) + */ +TEST (test_tensor_transform, typecast_1_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "uint32", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); /* input tensor info */ config.info.type = _NNS_UINT8; @@ -102,7 +176,953 @@ TEST (test_tensor_transform, typecast_1) /** * @brief Test for tensor_transform typecast (uint32 > float64) */ -TEST (test_tensor_transform, typecast_2) +TEST (test_tensor_transform, typecast_2) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float64", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT32; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT64; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint32_t value = (i + 1) * (b + 1); + ((uint32_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + double expected = (i + 1) * (b + 1); + EXPECT_DOUBLE_EQ (((double *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, uint32 > float64) + */ +TEST (test_tensor_transform, typecast_2_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float64", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT32; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT64; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint32_t value = (i + 1) * (b + 1); + ((uint32_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + double expected = (i + 1) * (b + 1); + EXPECT_DOUBLE_EQ (((double *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (int32 > float32) + */ +TEST (test_tensor_transform, typecast_3) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_INT32; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + int32_t value = (i + 1) * (b + 1) * (-1); + ((int32_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) * (-1.); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, int32 > float32) + */ +TEST (test_tensor_transform, typecast_3_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); + + /* input tensor info */ + config.info.type = _NNS_INT32; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + int32_t value = (i + 1) * (b + 1) * (-1); + ((int32_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) * (-1.); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (int8 > float32) + */ +TEST (test_tensor_transform, typecast_4) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_INT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + int8_t value = (i + 1) * (b + 1) * (-1); + ((int8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) * (-1.); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, int8 > float32) + */ +TEST (test_tensor_transform, typecast_4_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); + + /* input tensor info */ + config.info.type = _NNS_INT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + int8_t value = (i + 1) * (b + 1) * (-1); + ((int8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) * (-1.); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (uint8 > float32) + */ +TEST (test_tensor_transform, typecast_5) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint8_t value = (i + 1) * (b + 1); + ((uint8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, uint8 > float32) + */ +TEST (test_tensor_transform, typecast_5_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint8_t value = (i + 1) * (b + 1); + ((uint8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (int16 > float32) + */ +TEST (test_tensor_transform, typecast_6) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_INT16; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + int16_t value = (i + 1) * (b + 1) * (-1); + ((int16_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) * (-1.); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, int16 > float32) + */ +TEST (test_tensor_transform, typecast_6_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); + + /* input tensor info */ + config.info.type = _NNS_INT16; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + int16_t value = (i + 1) * (b + 1) * (-1); + ((int16_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) * (-1.); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (uint16 > float32) + */ +TEST (test_tensor_transform, typecast_7) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT16; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint16_t value = (i + 1) * (b + 1); + ((uint16_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform typecast (acceleration, uint16 > float32) + */ +TEST (test_tensor_transform, typecast_7_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "typecast", "option", "float32", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT16; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint16_t value = (i + 1) * (b + 1); + ((uint16_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1); + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform arithmetic (float32, add .5) + */ +TEST (test_tensor_transform, arithmetic_1) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "arithmetic", "option", "add:.5", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_FLOAT32; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + float value = (i + 1) * (b + 1) + .2; + ((float *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = (i + 1) * (b + 1) + .2 + .5; + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform arithmetic (acceleration, float32, add .5) + */ +TEST (test_tensor_transform, arithmetic_1_accel) { const guint num_buffers = 3; const guint array_size = 5; @@ -113,35 +1133,33 @@ TEST (test_tensor_transform, typecast_2) GstMemory *mem; GstMapInfo info; guint i, b; - gsize data_in_size, data_out_size; + gsize data_size; h = gst_harness_new ("tensor_transform"); - g_object_set (h->element, "mode", "typecast", "option", "float64", NULL); + g_object_set (h->element, "mode", "arithmetic", "option", "add:.5", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); /* input tensor info */ - config.info.type = _NNS_UINT32; + config.info.type = _NNS_FLOAT32; get_tensor_dimension ("5", config.info.dimension); config.rate_n = 0; config.rate_d = 1; gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); - data_in_size = gst_tensor_info_get_size (&config.info); - - config.info.type = _NNS_FLOAT64; - data_out_size = gst_tensor_info_get_size (&config.info); + data_size = gst_tensor_info_get_size (&config.info); /* push buffers */ for (b = 0; b < num_buffers; b++) { /* set input buffer */ - in_buf = gst_harness_create_buffer (h, data_in_size); + in_buf = gst_harness_create_buffer (h, data_size); mem = gst_buffer_peek_memory (in_buf, 0); ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); for (i = 0; i < array_size; i++) { - uint32_t value = (i + 1) * (b + 1); - ((uint32_t *) info.data)[i] = value; + float value = (i + 1) * (b + 1) + .2; + ((float *) info.data)[i] = value; } gst_memory_unmap (mem, &info); @@ -153,14 +1171,14 @@ TEST (test_tensor_transform, typecast_2) ASSERT_TRUE (out_buf != NULL); ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); - ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_size); mem = gst_buffer_peek_memory (out_buf, 0); ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); for (i = 0; i < array_size; i++) { - double expected = (i + 1) * (b + 1); - EXPECT_DOUBLE_EQ (((double *) info.data)[i], expected); + float expected = (i + 1) * (b + 1) + .2 + .5; + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); } gst_memory_unmap (mem, &info); @@ -172,9 +1190,9 @@ TEST (test_tensor_transform, typecast_2) } /** - * @brief Test for tensor_transform arithmetic (float32, add .5) + * @brief Test for tensor_transform arithmetic (float64, mul .5) */ -TEST (test_tensor_transform, arithmetic_1) +TEST (test_tensor_transform, arithmetic_2) { const guint num_buffers = 3; const guint array_size = 5; @@ -189,10 +1207,11 @@ TEST (test_tensor_transform, arithmetic_1) h = gst_harness_new ("tensor_transform"); - g_object_set (h->element, "mode", "arithmetic", "option", "add:.5", NULL); + g_object_set (h->element, "mode", "arithmetic", "option", "mul:.5", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); /* input tensor info */ - config.info.type = _NNS_FLOAT32; + config.info.type = _NNS_FLOAT64; get_tensor_dimension ("5", config.info.dimension); config.rate_n = 0; config.rate_d = 1; @@ -209,8 +1228,8 @@ TEST (test_tensor_transform, arithmetic_1) ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); for (i = 0; i < array_size; i++) { - float value = (i + 1) * (b + 1) + .2; - ((float *) info.data)[i] = value; + double value = (i + 1) * (b + 1) + .2; + ((double *) info.data)[i] = value; } gst_memory_unmap (mem, &info); @@ -228,8 +1247,8 @@ TEST (test_tensor_transform, arithmetic_1) ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); for (i = 0; i < array_size; i++) { - float expected = (i + 1) * (b + 1) + .2 + .5; - EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + double expected = ((i + 1) * (b + 1) + .2) * .5; + EXPECT_DOUBLE_EQ (((double *) info.data)[i], expected); } gst_memory_unmap (mem, &info); @@ -241,9 +1260,9 @@ TEST (test_tensor_transform, arithmetic_1) } /** - * @brief Test for tensor_transform arithmetic (float64, mul .5) + * @brief Test for tensor_transform arithmetic (acceleration, float64, mul .5) */ -TEST (test_tensor_transform, arithmetic_2) +TEST (test_tensor_transform, arithmetic_2_accel) { const guint num_buffers = 3; const guint array_size = 5; @@ -259,6 +1278,7 @@ TEST (test_tensor_transform, arithmetic_2) h = gst_harness_new ("tensor_transform"); g_object_set (h->element, "mode", "arithmetic", "option", "mul:.5", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); /* input tensor info */ config.info.type = _NNS_FLOAT64; @@ -329,6 +1349,81 @@ TEST (test_tensor_transform, arithmetic_3) g_object_set (h->element, "mode", "arithmetic", "option", "typecast:float32,add:.5,mul:0.2", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_UINT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint8_t value = (i + 1) * (b + 1); + ((uint8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + float expected = ((i + 1) * (b + 1) + .5) * .2; + EXPECT_FLOAT_EQ (((float *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform arithmetic (acceleration, typecast uint8 > float32, add .5, mul .2) + */ +TEST (test_tensor_transform, arithmetic_3_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "arithmetic", + "option", "typecast:float32,add:.5,mul:0.2", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); /* input tensor info */ config.info.type = _NNS_UINT8; @@ -402,6 +1497,81 @@ TEST (test_tensor_transform, arithmetic_4) g_object_set (h->element, "mode", "arithmetic", "option", "typecast:float64,add:0.2,add:0.1,typecast:uint16", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_FLOAT64; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint8_t value = (i + 1) * (b + 1); + ((uint8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + double expected = (i + 1) * (b + 1) + .3; + EXPECT_DOUBLE_EQ (((double *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform arithmetic (acceleration, typecast uint8 > float64, add .2, add .1, final typecast uint16 will be ignored) + */ +TEST (test_tensor_transform, arithmetic_4_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "arithmetic", + "option", "typecast:float64,add:0.2,add:0.1,typecast:uint16", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); /* input tensor info */ config.info.type = _NNS_UINT8; @@ -475,6 +1645,81 @@ TEST (test_tensor_transform, arithmetic_5) g_object_set (h->element, "mode", "arithmetic", "option", "typecast:int32,mul:2,div:2,add:-1", NULL); + g_object_set (h->element, "acceleration", (gboolean) FALSE, NULL); + + /* input tensor info */ + config.info.type = _NNS_UINT8; + get_tensor_dimension ("5", config.info.dimension); + config.rate_n = 0; + config.rate_d = 1; + + gst_harness_set_src_caps (h, gst_tensor_caps_from_config (&config)); + data_in_size = gst_tensor_info_get_size (&config.info); + + config.info.type = _NNS_INT32; + data_out_size = gst_tensor_info_get_size (&config.info); + + /* push buffers */ + for (b = 0; b < num_buffers; b++) { + /* set input buffer */ + in_buf = gst_harness_create_buffer (h, data_in_size); + + mem = gst_buffer_peek_memory (in_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_WRITE)); + + for (i = 0; i < array_size; i++) { + uint8_t value = (i + 1) * (b + 1); + ((uint8_t *) info.data)[i] = value; + } + + gst_memory_unmap (mem, &info); + + EXPECT_EQ (gst_harness_push (h, in_buf), GST_FLOW_OK); + + /* get output buffer */ + out_buf = gst_harness_pull (h); + + ASSERT_TRUE (out_buf != NULL); + ASSERT_EQ (gst_buffer_n_memory (out_buf), 1); + ASSERT_EQ (gst_buffer_get_size (out_buf), data_out_size); + + mem = gst_buffer_peek_memory (out_buf, 0); + ASSERT_TRUE (gst_memory_map (mem, &info, GST_MAP_READ)); + + for (i = 0; i < array_size; i++) { + int32_t expected = (i + 1) * (b + 1) - 1; + EXPECT_EQ (((int32_t *) info.data)[i], expected); + } + + gst_memory_unmap (mem, &info); + gst_buffer_unref (out_buf); + } + + EXPECT_EQ (gst_harness_buffers_received (h), num_buffers); + gst_harness_teardown (h); +} + +/** + * @brief Test for tensor_transform arithmetic (acceleration, typecast uint8 > int32, mul 2, div 2, add -1) + */ +TEST (test_tensor_transform, arithmetic_5_accel) +{ + const guint num_buffers = 3; + const guint array_size = 5; + + GstHarness *h; + GstBuffer *in_buf, *out_buf; + GstTensorConfig config; + GstMemory *mem; + GstMapInfo info; + guint i, b; + gsize data_in_size, data_out_size; + + h = gst_harness_new ("tensor_transform"); + + g_object_set (h->element, "mode", "arithmetic", + "option", "typecast:int32,mul:2,div:2,add:-1", NULL); + g_object_set (h->element, "acceleration", (gboolean) TRUE, NULL); /* input tensor info */ config.info.type = _NNS_UINT8; -- 2.7.4