test_conformance/test_lut.c - third_party/github.com/KhronosGroup/OpenVX-cts - Git at Google

 /*

  * 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.
  */

 #include "test_engine/test.h"
 #include <VX/vx.h>
 #include <VX/vxu.h>
 #include <string.h>


 TESTCASE(LUT, CT_VXContext, ct_setup_vx_context, 0)

 static vx_size lut_count(vx_enum data_type)
 {
     vx_size count = 0;

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         count = 256;
         break;
     case VX_TYPE_INT16:
         count = 65536;
         break;
     }

     return count;
 }

 static vx_size lut_size(vx_enum data_type)
 {
     vx_size size = 0;

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         size = 256*sizeof(vx_uint8);
         break;
     case VX_TYPE_INT16:
         size = 65536*sizeof(vx_int16);
         break;
     }

     return size;
 }

 static vx_lut lut_create(vx_context context, void* data, vx_enum data_type)
 {
     vx_size count = lut_count(data_type);
     vx_size size = lut_size(data_type);

     vx_lut lut = vxCreateLUT(context, data_type, count);
     void* ptr = NULL;

     ASSERT_VX_OBJECT_(return 0, lut, VX_TYPE_LUT);

     vx_map_id map_id;
     VX_CALL_(return 0, vxMapLUT(lut, &map_id, &ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
     ASSERT_(return 0, ptr);
     memcpy(ptr, data, size);
     VX_CALL_(return 0, vxUnmapLUT(lut, map_id));
     return lut;
 }

 static vx_lut virtual_lut_create(vx_context context, void* data, vx_enum data_type)
 {
     vx_graph graph = 0;
     graph = vxCreateGraph(context);
     vx_size count = lut_count(data_type);

     vx_lut lut = vxCreateVirtualLUT(graph, data_type, count);

     vxReleaseGraph(&graph);

     return lut;
 }

 static void lut_data_fill_identity(void* data, vx_enum data_type)
 {
     int i;

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         {
             vx_int32 offset = 0;
             vx_uint8* data8 = (vx_uint8*)data;
             for (i = 0; i < 256; ++i)
                 data8[i] = i - offset;
         }
         break;
     case VX_TYPE_INT16:
         {
             vx_int32 offset = 65536/2;
             vx_int16* data16 = (vx_int16*)data;
             for (i = 0; i < 65536; ++i)
                 data16[i] = i - offset;
         }
         break;
     }
 }

 static void lut_data_fill_random(void* data, vx_enum data_type)
 {
     uint64_t* seed = &CT()->seed_;
     int i;

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         {
             vx_uint8* data8 = (vx_uint8*)data;
             for (i = 0; i < 256; ++i)
                 data8[i] = (vx_uint8)CT_RNG_NEXT_INT(*seed, 0, 256);
         }
         break;
     case VX_TYPE_INT16:
         {
             vx_int16* data16 = (vx_int16*)data;
             for (i = 0; i < 65536; ++i)
                 data16[i] = (vx_int16)CT_RNG_NEXT_INT(*seed, (uint32_t)-32768, 32768);
         }
         break;
     }
 }

 TEST(LUT, testNodeCreation)
 {
     vx_context context = context_->vx_context_;
     vx_image src_image = 0, dst_image = 0;
     vx_uint8 lut_data[256];
     vx_lut lut = 0;
     vx_graph graph = 0;
     vx_node node = 0;
     vx_enum data_type = VX_TYPE_UINT8;

     src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
     ASSERT_VX_OBJECT(src_image, VX_TYPE_IMAGE);

     dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
     ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

     ASSERT_NO_FAILURE(lut_data_fill_identity(lut_data, data_type));
     ASSERT_VX_OBJECT(lut = lut_create(context, lut_data, data_type), VX_TYPE_LUT);

     {
         vx_enum lut_type;
         vx_size lut_count, lut_size;
         VX_CALL(vxQueryLUT(lut, VX_LUT_TYPE, &lut_type, sizeof(lut_type)));
         if (VX_TYPE_UINT8 != lut_type)
         {
             CT_FAIL("check for LUT attribute VX_LUT_TYPE failed\n");
         }
         VX_CALL(vxQueryLUT(lut, VX_LUT_COUNT, &lut_count, sizeof(lut_count)));
         if (256 != lut_count)
         {
             CT_FAIL("check for LUT attribute VX_LUT_COUNT failed\n");
         }
         VX_CALL(vxQueryLUT(lut, VX_LUT_SIZE, &lut_size, sizeof(lut_size)));
         if (256 > lut_size)
         {
             CT_FAIL("check for LUT attribute VX_LUT_SIZE failed\n");
         }
     }

     graph = vxCreateGraph(context);
     ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

     node = vxTableLookupNode(graph, src_image, lut, dst_image);
     ASSERT_VX_OBJECT(node, VX_TYPE_NODE);

     VX_CALL(vxReleaseNode(&node));
     VX_CALL(vxReleaseGraph(&graph));
     VX_CALL(vxReleaseLUT(&lut));
     VX_CALL(vxReleaseImage(&dst_image));
     VX_CALL(vxReleaseImage(&src_image));

     ASSERT(node == 0);
     ASSERT(graph == 0);
     ASSERT(lut == 0);
     ASSERT(dst_image == 0);
     ASSERT(src_image == 0);
 }

 TEST(LUT, testVirtualNodeCreation)
 {
     vx_context context = context_->vx_context_;
     vx_image src_image = 0, dst_image = 0;
     vx_uint8 lut_data[256];
     vx_lut lut = 0;
     src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
     ASSERT_VX_OBJECT(src_image, VX_TYPE_IMAGE);
     vx_graph graph = 0;
     vx_node node = 0;
     vx_enum data_type = VX_TYPE_UINT8;


     dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
     ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

     ASSERT_NO_FAILURE(lut_data_fill_identity(lut_data, data_type));
     ASSERT_VX_OBJECT(lut = virtual_lut_create(context, lut_data, data_type), VX_TYPE_LUT);

     {
         vx_enum lut_type;
         vx_size lut_count, lut_size;
         VX_CALL(vxQueryLUT(lut, VX_LUT_TYPE, &lut_type, sizeof(lut_type)));
         if (VX_TYPE_UINT8 != lut_type)
         {
             CT_FAIL("check for LUT attribute VX_LUT_TYPE failed\n");
         }
         VX_CALL(vxQueryLUT(lut, VX_LUT_COUNT, &lut_count, sizeof(lut_count)));
         if (256 != lut_count)
         {
             CT_FAIL("check for LUT attribute VX_LUT_COUNT failed\n");
         }
         VX_CALL(vxQueryLUT(lut, VX_LUT_SIZE, &lut_size, sizeof(lut_size)));
         if (256 > lut_size)
         {
             CT_FAIL("check for LUT attribute VX_LUT_SIZE failed\n");
         }
     }

     graph = vxCreateGraph(context);
     ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

     node = vxTableLookupNode(graph, src_image, lut, dst_image);
     ASSERT_VX_OBJECT(node, VX_TYPE_NODE);

     VX_CALL(vxReleaseNode(&node));
     VX_CALL(vxReleaseGraph(&graph));
     VX_CALL(vxReleaseLUT(&lut));
     VX_CALL(vxReleaseImage(&dst_image));
     VX_CALL(vxReleaseImage(&src_image));

     ASSERT(node == 0);
     ASSERT(graph == 0);
     ASSERT(lut == 0);
     ASSERT(dst_image == 0);
     ASSERT(src_image == 0);
 }

 // Generate input to cover these requirements:
 // There should be a image with randomly generated pixel intensities.
 static CT_Image lut_image_generate_random(const char* fileName, int width, int height, vx_enum data_type)
 {
     CT_Image image = 0;

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         image = ct_allocate_ct_image_random(width, height, VX_DF_IMAGE_U8, &CT()->seed_, 0, 256);
         break;
     case VX_TYPE_INT16:
         image = ct_allocate_ct_image_random(width, height, VX_DF_IMAGE_S16, &CT()->seed_, -32768, 32768);
         break;
     }
     ASSERT_(return 0, image != 0);

     return image;
 }

 static CT_Image lut_image_read(const char* fileName, int width, int height, vx_enum data_type)
 {
     CT_Image image8 = NULL;
     ASSERT_(return 0, width == 0 && height == 0);
     image8 = ct_read_image(fileName, 1);
     ASSERT_(return 0, image8);
     ASSERT_(return 0, image8->format == VX_DF_IMAGE_U8);

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         return image8;
     case VX_TYPE_INT16:
         {
             vx_int32 offset = 65536/2;
             CT_Image image16 = ct_allocate_image(image8->width, image8->height, VX_DF_IMAGE_S16);
             if (image16)
             {
                 CT_FILL_IMAGE_16S(return 0, image16,
                     {
                         vx_uint8 value8 = *CT_IMAGE_DATA_PTR_8U(image8, x, y);
                         vx_uint16 value16 = ((vx_uint16)value8 << 8) | value8;
                         vx_int16 res = (vx_int16)((vx_int32)value16 - offset);
                         *dst_data = res;
                     });
             }
             return image16;
         }
     }

     return NULL;
 }

 // data_type == VX_TYPE_UINT8
 static vx_uint8 lut_calculate_u8(CT_Image src, uint32_t x, uint32_t y, void* lut_data)
 {
     vx_uint8* lut_data8 = (vx_uint8*)lut_data;
     vx_int32 offset = 0;
     vx_uint8 value = *CT_IMAGE_DATA_PTR_8U(src, x, y);
     vx_uint8 res = lut_data8[offset + value];
     return res;
 }

 // data_type == VX_TYPE_INT16
 static vx_int16 lut_calculate_s16(CT_Image src, uint32_t x, uint32_t y, void* lut_data)
 {
     vx_int16* lut_data16 = (vx_int16*)lut_data;
     vx_int32 offset = 65536/2;
     vx_int16 value = *CT_IMAGE_DATA_PTR_16S(src, x, y);
     vx_int16 res = lut_data16[offset + value];
     return res;
 }

 static CT_Image lut_create_reference_image(CT_Image src, void* lut_data, vx_enum data_type)
 {
     CT_Image dst;

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         CT_ASSERT_(return NULL, src->format == VX_DF_IMAGE_U8);
         break;
     case VX_TYPE_INT16:
         CT_ASSERT_(return NULL, src->format == VX_DF_IMAGE_S16);
         break;
     }

     dst = ct_allocate_image(src->width, src->height, src->format);

     switch (data_type)
     {
     case VX_TYPE_UINT8:
         CT_FILL_IMAGE_8U(return 0, dst,
             {
                 uint8_t res = lut_calculate_u8(src, x, y, lut_data);
                 *dst_data = res;
             });
         break;
     case VX_TYPE_INT16:
         CT_FILL_IMAGE_16S(return 0, dst,
             {
                 int16_t res = lut_calculate_s16(src, x, y, lut_data);
                 *dst_data = res;
             });
         break;
     }

     return dst;
 }


 static void lut_check(CT_Image src, CT_Image dst, void* lut_data, vx_enum data_type)
 {
     CT_Image dst_ref = NULL;

     ASSERT(src && dst);

     ASSERT_NO_FAILURE(dst_ref = lut_create_reference_image(src, lut_data, data_type));

     EXPECT_EQ_CTIMAGE(dst_ref, dst);
 #if 0
     if (CT_HasFailure())
     {
         int i = 0;
         printf("=== LUT ===\n");
         switch (data_type)
         {
         case VX_TYPE_UINT8:
             for (i = 0; i < 256; ++i)
                 printf("%3d:%3d ", i, (int)((vx_uint8*)lut_data)[i]);
             break;
         case VX_TYPE_INT16:
             for (i = 0; i < 65536; ++i)
                 printf("%5d:%6d ", i, (int)((vx_int16*)lut_data)[i]);
             break;
         }
         printf("\n");
         printf("=== SRC ===\n");
         ct_dump_image_info(src);
         printf("=== DST ===\n");
         ct_dump_image_info(dst);
         printf("=== EXPECTED ===\n");
         ct_dump_image_info(dst_ref);
     }
 #endif
 }

 typedef struct {
     const char* testName;
     CT_Image (*generator)(const char* fileName, int width, int height, vx_enum data_type);
     const char* fileName;
     void (*lut_generator)(void* data, vx_enum data_type);
     int width, height;
     vx_enum data_type;
 } Arg;

 #define ADD_LUT_GENERATOR(testArgName, nextmacro, ...) \
     CT_EXPAND(nextmacro(testArgName "/LutIdentity", __VA_ARGS__, lut_data_fill_identity)), \
     CT_EXPAND(nextmacro(testArgName "/LutRandom", __VA_ARGS__, lut_data_fill_random))

 #define ADD_TYPE(testArgName, nextmacro, ...) \
     CT_EXPAND(nextmacro(testArgName "/U8", __VA_ARGS__, VX_TYPE_UINT8)), \
     CT_EXPAND(nextmacro(testArgName "/S16", __VA_ARGS__, VX_TYPE_INT16))

 #define LUT_PARAMETERS                                                \
     CT_GENERATE_PARAMETERS("randomInput", ADD_LUT_GENERATOR, ADD_SIZE_SMALL_SET, ADD_TYPE, ARG, lut_image_generate_random, NULL), \
     CT_GENERATE_PARAMETERS("lena", ADD_LUT_GENERATOR, ADD_SIZE_NONE, ADD_TYPE, ARG, lut_image_read, "lena.bmp")

 TEST_WITH_ARG(LUT, testGraphProcessing, Arg,
     LUT_PARAMETERS
 )
 {
     vx_enum data_type = arg_->data_type;
     vx_context context = context_->vx_context_;
     vx_image src_image = 0, dst_image = 0;
     vx_graph graph = 0;
     vx_node node = 0;

     CT_Image src = NULL, dst = NULL;
     void* lut_data;
     vx_lut lut;
     vx_size size;

     size = lut_size(data_type);
     lut_data = ct_alloc_mem(size);
     ASSERT(lut_data != 0);

     ASSERT_NO_FAILURE(src = arg_->generator(arg_->fileName, arg_->width, arg_->height, data_type));

     ASSERT_VX_OBJECT(src_image = ct_image_to_vx_image(src, context), VX_TYPE_IMAGE);

     ASSERT_NO_FAILURE(arg_->lut_generator(lut_data, data_type));
     ASSERT_VX_OBJECT(lut = lut_create(context, lut_data, data_type), VX_TYPE_LUT);

     dst_image = ct_create_similar_image(src_image);
     ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

     graph = vxCreateGraph(context);
     ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

     node = vxTableLookupNode(graph, src_image, lut, dst_image);
     ASSERT_VX_OBJECT(node, VX_TYPE_NODE);

     VX_CALL(vxVerifyGraph(graph));
     VX_CALL(vxProcessGraph(graph));

     ASSERT_NO_FAILURE(dst = ct_image_from_vx_image(dst_image));

     ASSERT_NO_FAILURE(lut_check(src, dst, lut_data, data_type));

     VX_CALL(vxReleaseNode(&node));
     VX_CALL(vxReleaseGraph(&graph));

     ASSERT(node == 0);
     ASSERT(graph == 0);

     VX_CALL(vxReleaseLUT(&lut));
     VX_CALL(vxReleaseImage(&dst_image));
     VX_CALL(vxReleaseImage(&src_image));

     ASSERT(lut == 0);
     ASSERT(dst_image == 0);
     ASSERT(src_image == 0);

     ct_free_mem(lut_data);
 }

 TEST_WITH_ARG(LUT, testImmediateProcessing, Arg,
     LUT_PARAMETERS
 )
 {
     vx_enum data_type = arg_->data_type;
     vx_context context = context_->vx_context_;
     vx_image src_image = 0, dst_image = 0;

     CT_Image src = NULL, dst = NULL;
     void* lut_data;
     vx_lut lut;
     vx_size size;

     size = lut_size(data_type);
     lut_data = ct_alloc_mem(size);
     ASSERT(lut_data != 0);

     ASSERT_NO_FAILURE(src = arg_->generator(arg_->fileName, arg_->width, arg_->height, data_type));

     ASSERT_VX_OBJECT(src_image = ct_image_to_vx_image(src, context), VX_TYPE_IMAGE);

     ASSERT_NO_FAILURE(arg_->lut_generator(lut_data, data_type));
     ASSERT_VX_OBJECT(lut = lut_create(context, lut_data, data_type), VX_TYPE_LUT);

     dst_image = ct_create_similar_image(src_image);
     ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

     VX_CALL(vxuTableLookup(context, src_image, lut, dst_image));

     ASSERT_NO_FAILURE(dst = ct_image_from_vx_image(dst_image));

     ASSERT_NO_FAILURE(lut_check(src, dst, lut_data, data_type));

     VX_CALL(vxReleaseLUT(&lut));
     VX_CALL(vxReleaseImage(&dst_image));
     VX_CALL(vxReleaseImage(&src_image));

     ASSERT(lut == 0);
     ASSERT(dst_image == 0);
     ASSERT(src_image == 0);

     ct_free_mem(lut_data);
 }

 typedef struct {
     const char* name;
     vx_enum type;
 } data_type_arg;

 TEST_WITH_ARG(LUT, test_vxCopyLUT, data_type_arg,
               ARG_ENUM(VX_TYPE_UINT8),
               ARG_ENUM(VX_TYPE_INT16))
 {
     vx_context context = context_->vx_context_;
     vx_enum data_type = arg_->type;
     vx_lut lut;
     vx_size size = lut_size(data_type);
     vx_size i;

     void* identity_data = ct_alloc_mem(size);
     ASSERT(identity_data != 0);
     ASSERT_NO_FAILURE(lut_data_fill_identity(identity_data, data_type));
     ASSERT_VX_OBJECT(lut = lut_create(context, identity_data, data_type), VX_TYPE_LUT);
     /* read only mode */
     void* user_data = ct_alloc_mem(size);
     VX_CALL(vxCopyLUT(lut, user_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
     /* Check */
     for (i = 0; i < size; i++)
     {
         ASSERT(((vx_uint8*)user_data)[i] == ((vx_uint8*)identity_data)[i]);
     }
     /* write only mode */
     void* random_data = ct_alloc_mem(size);
     ASSERT_NO_FAILURE(lut_data_fill_random(random_data, data_type));
     VX_CALL(vxCopyLUT(lut, random_data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
     /* Check */
     vx_map_id map_id;
     void* lut_data = NULL;
     VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));
     for (i = 0; i < size; i++)
     {
         ASSERT(((vx_uint8*)lut_data)[i] == ((vx_uint8*)random_data)[i]);
     }
     VX_CALL(vxUnmapLUT(lut, map_id));

     VX_CALL(vxReleaseLUT(&lut));
     ASSERT(lut == 0);

     ct_free_mem(identity_data);
     ct_free_mem(user_data);
     ct_free_mem(random_data);
 }

 TEST_WITH_ARG(LUT, test_vxMapLUTWrite, data_type_arg,
               ARG_ENUM(VX_TYPE_UINT8),
               ARG_ENUM(VX_TYPE_INT16))
 {
     vx_context context = context_->vx_context_;
     vx_enum data_type = arg_->type;
     vx_lut lut;
     vx_size size = lut_size(data_type);
     void* identity_data = ct_alloc_mem(size);
     vx_size i;

     ASSERT(identity_data != 0);
     ASSERT_NO_FAILURE(lut_data_fill_identity(identity_data, data_type));
     ASSERT_VX_OBJECT(lut = lut_create(context, identity_data, data_type), VX_TYPE_LUT);
     /* Read and write mode, read */
     vx_map_id map_id;
     void* lut_data = NULL;
     VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0));
     /* Check */
     for (i = 0; i < size; i++)
     {
         ASSERT(((vx_uint8*)lut_data)[i] == ((vx_uint8*)identity_data)[i]);
     }
     /* Read and write mode, write */
     void* random_data = ct_alloc_mem(size);
     ASSERT_NO_FAILURE(lut_data_fill_random(random_data, data_type));
     memcpy(lut_data, random_data, size);
     VX_CALL(vxUnmapLUT(lut, map_id));
     /* Check */
     lut_data = NULL;
     VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));
     for (i = 0; i < size; i++)
     {
         ASSERT(((vx_uint8*)lut_data)[i] == ((vx_uint8*)random_data)[i]);
     }
     VX_CALL(vxUnmapLUT(lut, map_id));

     /* Write only mode */
     VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0));
     ASSERT_NO_FAILURE(lut_data_fill_identity(lut_data, data_type));
     VX_CALL(vxUnmapLUT(lut, map_id));
     /* Check */
     lut_data = NULL;
     VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));
     for ( i = 0; i < size; i++)
     {
         ASSERT(((vx_uint8*)lut_data)[i] == ((vx_uint8*)identity_data)[i]);
     }
     VX_CALL(vxUnmapLUT(lut, map_id));

     VX_CALL(vxReleaseLUT(&lut));
     ASSERT(lut == 0);

     ct_free_mem(identity_data);
     ct_free_mem(random_data);
 }

 TESTCASE_TESTS(LUT,
                testNodeCreation,
                testVirtualNodeCreation,
                testGraphProcessing,
                testImmediateProcessing,
                test_vxCopyLUT,
                test_vxMapLUTWrite)
	/*

	* 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.
	*/

	#include "test_engine/test.h"
	#include <VX/vx.h>
	#include <VX/vxu.h>
	#include <string.h>


	TESTCASE(LUT, CT_VXContext, ct_setup_vx_context, 0)

	static vx_size lut_count(vx_enum data_type)
	{
	vx_size count = 0;

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	count = 256;
	break;
	case VX_TYPE_INT16:
	count = 65536;
	break;
	}

	return count;
	}

	static vx_size lut_size(vx_enum data_type)
	{
	vx_size size = 0;

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	size = 256*sizeof(vx_uint8);
	break;
	case VX_TYPE_INT16:
	size = 65536*sizeof(vx_int16);
	break;
	}

	return size;
	}

	static vx_lut lut_create(vx_context context, void* data, vx_enum data_type)
	{
	vx_size count = lut_count(data_type);
	vx_size size = lut_size(data_type);

	vx_lut lut = vxCreateLUT(context, data_type, count);
	void* ptr = NULL;

	ASSERT_VX_OBJECT_(return 0, lut, VX_TYPE_LUT);

	vx_map_id map_id;
	VX_CALL_(return 0, vxMapLUT(lut, &map_id, &ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0));
	ASSERT_(return 0, ptr);
	memcpy(ptr, data, size);
	VX_CALL_(return 0, vxUnmapLUT(lut, map_id));
	return lut;
	}

	static vx_lut virtual_lut_create(vx_context context, void* data, vx_enum data_type)
	{
	vx_graph graph = 0;
	graph = vxCreateGraph(context);
	vx_size count = lut_count(data_type);

	vx_lut lut = vxCreateVirtualLUT(graph, data_type, count);

	vxReleaseGraph(&graph);

	return lut;
	}

	static void lut_data_fill_identity(void* data, vx_enum data_type)
	{
	int i;

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	{
	vx_int32 offset = 0;
	vx_uint8* data8 = (vx_uint8*)data;
	for (i = 0; i < 256; ++i)
	data8[i] = i - offset;
	}
	break;
	case VX_TYPE_INT16:
	{
	vx_int32 offset = 65536/2;
	vx_int16* data16 = (vx_int16*)data;
	for (i = 0; i < 65536; ++i)
	data16[i] = i - offset;
	}
	break;
	}
	}

	static void lut_data_fill_random(void* data, vx_enum data_type)
	{
	uint64_t* seed = &CT()->seed_;
	int i;

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	{
	vx_uint8* data8 = (vx_uint8*)data;
	for (i = 0; i < 256; ++i)
	data8[i] = (vx_uint8)CT_RNG_NEXT_INT(*seed, 0, 256);
	}
	break;
	case VX_TYPE_INT16:
	{
	vx_int16* data16 = (vx_int16*)data;
	for (i = 0; i < 65536; ++i)
	data16[i] = (vx_int16)CT_RNG_NEXT_INT(*seed, (uint32_t)-32768, 32768);
	}
	break;
	}
	}

	TEST(LUT, testNodeCreation)
	{
	vx_context context = context_->vx_context_;
	vx_image src_image = 0, dst_image = 0;
	vx_uint8 lut_data[256];
	vx_lut lut = 0;
	vx_graph graph = 0;
	vx_node node = 0;
	vx_enum data_type = VX_TYPE_UINT8;

	src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
	ASSERT_VX_OBJECT(src_image, VX_TYPE_IMAGE);

	dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
	ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

	ASSERT_NO_FAILURE(lut_data_fill_identity(lut_data, data_type));
	ASSERT_VX_OBJECT(lut = lut_create(context, lut_data, data_type), VX_TYPE_LUT);

	{
	vx_enum lut_type;
	vx_size lut_count, lut_size;
	VX_CALL(vxQueryLUT(lut, VX_LUT_TYPE, &lut_type, sizeof(lut_type)));
	if (VX_TYPE_UINT8 != lut_type)
	{
	CT_FAIL("check for LUT attribute VX_LUT_TYPE failed\n");
	}
	VX_CALL(vxQueryLUT(lut, VX_LUT_COUNT, &lut_count, sizeof(lut_count)));
	if (256 != lut_count)
	{
	CT_FAIL("check for LUT attribute VX_LUT_COUNT failed\n");
	}
	VX_CALL(vxQueryLUT(lut, VX_LUT_SIZE, &lut_size, sizeof(lut_size)));
	if (256 > lut_size)
	{
	CT_FAIL("check for LUT attribute VX_LUT_SIZE failed\n");
	}
	}

	graph = vxCreateGraph(context);
	ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

	node = vxTableLookupNode(graph, src_image, lut, dst_image);
	ASSERT_VX_OBJECT(node, VX_TYPE_NODE);

	VX_CALL(vxReleaseNode(&node));
	VX_CALL(vxReleaseGraph(&graph));
	VX_CALL(vxReleaseLUT(&lut));
	VX_CALL(vxReleaseImage(&dst_image));
	VX_CALL(vxReleaseImage(&src_image));

	ASSERT(node == 0);
	ASSERT(graph == 0);
	ASSERT(lut == 0);
	ASSERT(dst_image == 0);
	ASSERT(src_image == 0);
	}

	TEST(LUT, testVirtualNodeCreation)
	{
	vx_context context = context_->vx_context_;
	vx_image src_image = 0, dst_image = 0;
	vx_uint8 lut_data[256];
	vx_lut lut = 0;
	src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
	ASSERT_VX_OBJECT(src_image, VX_TYPE_IMAGE);
	vx_graph graph = 0;
	vx_node node = 0;
	vx_enum data_type = VX_TYPE_UINT8;


	dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8);
	ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

	ASSERT_NO_FAILURE(lut_data_fill_identity(lut_data, data_type));
	ASSERT_VX_OBJECT(lut = virtual_lut_create(context, lut_data, data_type), VX_TYPE_LUT);

	{
	vx_enum lut_type;
	vx_size lut_count, lut_size;
	VX_CALL(vxQueryLUT(lut, VX_LUT_TYPE, &lut_type, sizeof(lut_type)));
	if (VX_TYPE_UINT8 != lut_type)
	{
	CT_FAIL("check for LUT attribute VX_LUT_TYPE failed\n");
	}
	VX_CALL(vxQueryLUT(lut, VX_LUT_COUNT, &lut_count, sizeof(lut_count)));
	if (256 != lut_count)
	{
	CT_FAIL("check for LUT attribute VX_LUT_COUNT failed\n");
	}
	VX_CALL(vxQueryLUT(lut, VX_LUT_SIZE, &lut_size, sizeof(lut_size)));
	if (256 > lut_size)
	{
	CT_FAIL("check for LUT attribute VX_LUT_SIZE failed\n");
	}
	}

	graph = vxCreateGraph(context);
	ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

	node = vxTableLookupNode(graph, src_image, lut, dst_image);
	ASSERT_VX_OBJECT(node, VX_TYPE_NODE);

	VX_CALL(vxReleaseNode(&node));
	VX_CALL(vxReleaseGraph(&graph));
	VX_CALL(vxReleaseLUT(&lut));
	VX_CALL(vxReleaseImage(&dst_image));
	VX_CALL(vxReleaseImage(&src_image));

	ASSERT(node == 0);
	ASSERT(graph == 0);
	ASSERT(lut == 0);
	ASSERT(dst_image == 0);
	ASSERT(src_image == 0);
	}

	// Generate input to cover these requirements:
	// There should be a image with randomly generated pixel intensities.
	static CT_Image lut_image_generate_random(const char* fileName, int width, int height, vx_enum data_type)
	{
	CT_Image image = 0;

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	image = ct_allocate_ct_image_random(width, height, VX_DF_IMAGE_U8, &CT()->seed_, 0, 256);
	break;
	case VX_TYPE_INT16:
	image = ct_allocate_ct_image_random(width, height, VX_DF_IMAGE_S16, &CT()->seed_, -32768, 32768);
	break;
	}
	ASSERT_(return 0, image != 0);

	return image;
	}

	static CT_Image lut_image_read(const char* fileName, int width, int height, vx_enum data_type)
	{
	CT_Image image8 = NULL;
	ASSERT_(return 0, width == 0 && height == 0);
	image8 = ct_read_image(fileName, 1);
	ASSERT_(return 0, image8);
	ASSERT_(return 0, image8->format == VX_DF_IMAGE_U8);

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	return image8;
	case VX_TYPE_INT16:
	{
	vx_int32 offset = 65536/2;
	CT_Image image16 = ct_allocate_image(image8->width, image8->height, VX_DF_IMAGE_S16);
	if (image16)
	{
	CT_FILL_IMAGE_16S(return 0, image16,
	{
	vx_uint8 value8 = *CT_IMAGE_DATA_PTR_8U(image8, x, y);
	vx_uint16 value16 = ((vx_uint16)value8 << 8) \| value8;
	vx_int16 res = (vx_int16)((vx_int32)value16 - offset);
	*dst_data = res;
	});
	}
	return image16;
	}
	}

	return NULL;
	}

	// data_type == VX_TYPE_UINT8
	static vx_uint8 lut_calculate_u8(CT_Image src, uint32_t x, uint32_t y, void* lut_data)
	{
	vx_uint8* lut_data8 = (vx_uint8*)lut_data;
	vx_int32 offset = 0;
	vx_uint8 value = *CT_IMAGE_DATA_PTR_8U(src, x, y);
	vx_uint8 res = lut_data8[offset + value];
	return res;
	}

	// data_type == VX_TYPE_INT16
	static vx_int16 lut_calculate_s16(CT_Image src, uint32_t x, uint32_t y, void* lut_data)
	{
	vx_int16* lut_data16 = (vx_int16*)lut_data;
	vx_int32 offset = 65536/2;
	vx_int16 value = *CT_IMAGE_DATA_PTR_16S(src, x, y);
	vx_int16 res = lut_data16[offset + value];
	return res;
	}

	static CT_Image lut_create_reference_image(CT_Image src, void* lut_data, vx_enum data_type)
	{
	CT_Image dst;

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	CT_ASSERT_(return NULL, src->format == VX_DF_IMAGE_U8);
	break;
	case VX_TYPE_INT16:
	CT_ASSERT_(return NULL, src->format == VX_DF_IMAGE_S16);
	break;
	}

	dst = ct_allocate_image(src->width, src->height, src->format);

	switch (data_type)
	{
	case VX_TYPE_UINT8:
	CT_FILL_IMAGE_8U(return 0, dst,
	{
	uint8_t res = lut_calculate_u8(src, x, y, lut_data);
	*dst_data = res;
	});
	break;
	case VX_TYPE_INT16:
	CT_FILL_IMAGE_16S(return 0, dst,
	{
	int16_t res = lut_calculate_s16(src, x, y, lut_data);
	*dst_data = res;
	});
	break;
	}

	return dst;
	}


	static void lut_check(CT_Image src, CT_Image dst, void* lut_data, vx_enum data_type)
	{
	CT_Image dst_ref = NULL;

	ASSERT(src && dst);

	ASSERT_NO_FAILURE(dst_ref = lut_create_reference_image(src, lut_data, data_type));

	EXPECT_EQ_CTIMAGE(dst_ref, dst);
	#if 0
	if (CT_HasFailure())
	{
	int i = 0;
	printf("=== LUT ===\n");
	switch (data_type)
	{
	case VX_TYPE_UINT8:
	for (i = 0; i < 256; ++i)
	printf("%3d:%3d ", i, (int)((vx_uint8*)lut_data)[i]);
	break;
	case VX_TYPE_INT16:
	for (i = 0; i < 65536; ++i)
	printf("%5d:%6d ", i, (int)((vx_int16*)lut_data)[i]);
	break;
	}
	printf("\n");
	printf("=== SRC ===\n");
	ct_dump_image_info(src);
	printf("=== DST ===\n");
	ct_dump_image_info(dst);
	printf("=== EXPECTED ===\n");
	ct_dump_image_info(dst_ref);
	}
	#endif
	}

	typedef struct {
	const char* testName;
	CT_Image (generator)(const char fileName, int width, int height, vx_enum data_type);
	const char* fileName;
	void (lut_generator)(void data, vx_enum data_type);
	int width, height;
	vx_enum data_type;
	} Arg;

	#define ADD_LUT_GENERATOR(testArgName, nextmacro, ...) \
	CT_EXPAND(nextmacro(testArgName "/LutIdentity", __VA_ARGS__, lut_data_fill_identity)), \
	CT_EXPAND(nextmacro(testArgName "/LutRandom", __VA_ARGS__, lut_data_fill_random))

	#define ADD_TYPE(testArgName, nextmacro, ...) \
	CT_EXPAND(nextmacro(testArgName "/U8", __VA_ARGS__, VX_TYPE_UINT8)), \
	CT_EXPAND(nextmacro(testArgName "/S16", __VA_ARGS__, VX_TYPE_INT16))

	#define LUT_PARAMETERS \
	CT_GENERATE_PARAMETERS("randomInput", ADD_LUT_GENERATOR, ADD_SIZE_SMALL_SET, ADD_TYPE, ARG, lut_image_generate_random, NULL), \
	CT_GENERATE_PARAMETERS("lena", ADD_LUT_GENERATOR, ADD_SIZE_NONE, ADD_TYPE, ARG, lut_image_read, "lena.bmp")

	TEST_WITH_ARG(LUT, testGraphProcessing, Arg,
	LUT_PARAMETERS
	)
	{
	vx_enum data_type = arg_->data_type;
	vx_context context = context_->vx_context_;
	vx_image src_image = 0, dst_image = 0;
	vx_graph graph = 0;
	vx_node node = 0;

	CT_Image src = NULL, dst = NULL;
	void* lut_data;
	vx_lut lut;
	vx_size size;

	size = lut_size(data_type);
	lut_data = ct_alloc_mem(size);
	ASSERT(lut_data != 0);

	ASSERT_NO_FAILURE(src = arg_->generator(arg_->fileName, arg_->width, arg_->height, data_type));

	ASSERT_VX_OBJECT(src_image = ct_image_to_vx_image(src, context), VX_TYPE_IMAGE);

	ASSERT_NO_FAILURE(arg_->lut_generator(lut_data, data_type));
	ASSERT_VX_OBJECT(lut = lut_create(context, lut_data, data_type), VX_TYPE_LUT);

	dst_image = ct_create_similar_image(src_image);
	ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

	graph = vxCreateGraph(context);
	ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);

	node = vxTableLookupNode(graph, src_image, lut, dst_image);
	ASSERT_VX_OBJECT(node, VX_TYPE_NODE);

	VX_CALL(vxVerifyGraph(graph));
	VX_CALL(vxProcessGraph(graph));

	ASSERT_NO_FAILURE(dst = ct_image_from_vx_image(dst_image));

	ASSERT_NO_FAILURE(lut_check(src, dst, lut_data, data_type));

	VX_CALL(vxReleaseNode(&node));
	VX_CALL(vxReleaseGraph(&graph));

	ASSERT(node == 0);
	ASSERT(graph == 0);

	VX_CALL(vxReleaseLUT(&lut));
	VX_CALL(vxReleaseImage(&dst_image));
	VX_CALL(vxReleaseImage(&src_image));

	ASSERT(lut == 0);
	ASSERT(dst_image == 0);
	ASSERT(src_image == 0);

	ct_free_mem(lut_data);
	}

	TEST_WITH_ARG(LUT, testImmediateProcessing, Arg,
	LUT_PARAMETERS
	)
	{
	vx_enum data_type = arg_->data_type;
	vx_context context = context_->vx_context_;
	vx_image src_image = 0, dst_image = 0;

	CT_Image src = NULL, dst = NULL;
	void* lut_data;
	vx_lut lut;
	vx_size size;

	size = lut_size(data_type);
	lut_data = ct_alloc_mem(size);
	ASSERT(lut_data != 0);

	ASSERT_NO_FAILURE(src = arg_->generator(arg_->fileName, arg_->width, arg_->height, data_type));

	ASSERT_VX_OBJECT(src_image = ct_image_to_vx_image(src, context), VX_TYPE_IMAGE);

	ASSERT_NO_FAILURE(arg_->lut_generator(lut_data, data_type));
	ASSERT_VX_OBJECT(lut = lut_create(context, lut_data, data_type), VX_TYPE_LUT);

	dst_image = ct_create_similar_image(src_image);
	ASSERT_VX_OBJECT(dst_image, VX_TYPE_IMAGE);

	VX_CALL(vxuTableLookup(context, src_image, lut, dst_image));

	ASSERT_NO_FAILURE(dst = ct_image_from_vx_image(dst_image));

	ASSERT_NO_FAILURE(lut_check(src, dst, lut_data, data_type));

	VX_CALL(vxReleaseLUT(&lut));
	VX_CALL(vxReleaseImage(&dst_image));
	VX_CALL(vxReleaseImage(&src_image));

	ASSERT(lut == 0);
	ASSERT(dst_image == 0);
	ASSERT(src_image == 0);

	ct_free_mem(lut_data);
	}

	typedef struct {
	const char* name;
	vx_enum type;
	} data_type_arg;

	TEST_WITH_ARG(LUT, test_vxCopyLUT, data_type_arg,
	ARG_ENUM(VX_TYPE_UINT8),
	ARG_ENUM(VX_TYPE_INT16))
	{
	vx_context context = context_->vx_context_;
	vx_enum data_type = arg_->type;
	vx_lut lut;
	vx_size size = lut_size(data_type);
	vx_size i;

	void* identity_data = ct_alloc_mem(size);
	ASSERT(identity_data != 0);
	ASSERT_NO_FAILURE(lut_data_fill_identity(identity_data, data_type));
	ASSERT_VX_OBJECT(lut = lut_create(context, identity_data, data_type), VX_TYPE_LUT);
	/* read only mode */
	void* user_data = ct_alloc_mem(size);
	VX_CALL(vxCopyLUT(lut, user_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
	/* Check */
	for (i = 0; i < size; i++)
	{
	ASSERT(((vx_uint8)user_data)[i] == ((vx_uint8)identity_data)[i]);
	}
	/* write only mode */
	void* random_data = ct_alloc_mem(size);
	ASSERT_NO_FAILURE(lut_data_fill_random(random_data, data_type));
	VX_CALL(vxCopyLUT(lut, random_data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
	/* Check */
	vx_map_id map_id;
	void* lut_data = NULL;
	VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));
	for (i = 0; i < size; i++)
	{
	ASSERT(((vx_uint8)lut_data)[i] == ((vx_uint8)random_data)[i]);
	}
	VX_CALL(vxUnmapLUT(lut, map_id));

	VX_CALL(vxReleaseLUT(&lut));
	ASSERT(lut == 0);

	ct_free_mem(identity_data);
	ct_free_mem(user_data);
	ct_free_mem(random_data);
	}

	TEST_WITH_ARG(LUT, test_vxMapLUTWrite, data_type_arg,
	ARG_ENUM(VX_TYPE_UINT8),
	ARG_ENUM(VX_TYPE_INT16))
	{
	vx_context context = context_->vx_context_;
	vx_enum data_type = arg_->type;
	vx_lut lut;
	vx_size size = lut_size(data_type);
	void* identity_data = ct_alloc_mem(size);
	vx_size i;

	ASSERT(identity_data != 0);
	ASSERT_NO_FAILURE(lut_data_fill_identity(identity_data, data_type));
	ASSERT_VX_OBJECT(lut = lut_create(context, identity_data, data_type), VX_TYPE_LUT);
	/* Read and write mode, read */
	vx_map_id map_id;
	void* lut_data = NULL;
	VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0));
	/* Check */
	for (i = 0; i < size; i++)
	{
	ASSERT(((vx_uint8)lut_data)[i] == ((vx_uint8)identity_data)[i]);
	}
	/* Read and write mode, write */
	void* random_data = ct_alloc_mem(size);
	ASSERT_NO_FAILURE(lut_data_fill_random(random_data, data_type));
	memcpy(lut_data, random_data, size);
	VX_CALL(vxUnmapLUT(lut, map_id));
	/* Check */
	lut_data = NULL;
	VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));
	for (i = 0; i < size; i++)
	{
	ASSERT(((vx_uint8)lut_data)[i] == ((vx_uint8)random_data)[i]);
	}
	VX_CALL(vxUnmapLUT(lut, map_id));

	/* Write only mode */
	VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_AND_WRITE, VX_MEMORY_TYPE_HOST, 0));
	ASSERT_NO_FAILURE(lut_data_fill_identity(lut_data, data_type));
	VX_CALL(vxUnmapLUT(lut, map_id));
	/* Check */
	lut_data = NULL;
	VX_CALL(vxMapLUT(lut, &map_id, &lut_data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));
	for ( i = 0; i < size; i++)
	{
	ASSERT(((vx_uint8)lut_data)[i] == ((vx_uint8)identity_data)[i]);
	}
	VX_CALL(vxUnmapLUT(lut, map_id));

	VX_CALL(vxReleaseLUT(&lut));
	ASSERT(lut == 0);

	ct_free_mem(identity_data);
	ct_free_mem(random_data);
	}

	TESTCASE_TESTS(LUT,
	testNodeCreation,
	testVirtualNodeCreation,
	testGraphProcessing,
	testImmediateProcessing,
	test_vxCopyLUT,
	test_vxMapLUTWrite)