/*

 * 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 <math.h>
#include <string.h>

#if defined (_WIN32)
#include <windows.h>
#else
#include <unistd.h>
#endif

#include "test.h"

// As for OpenVX 1.0 both of following defines result in udefined behavior:
// #define OPENVX_PLANE_COPYING_VARIANT1
// #define OPENVX_PLANE_COPYING_VARIANT2

#define CT_ENUM_TO_STR(code) case code: return #code;

const char* ct_vx_status_to_str(vx_status s)
{
    switch(s)
    {
        CT_ENUM_TO_STR(VX_STATUS_MIN)
        CT_ENUM_TO_STR(VX_ERROR_REFERENCE_NONZERO)
        CT_ENUM_TO_STR(VX_ERROR_MULTIPLE_WRITERS)
        CT_ENUM_TO_STR(VX_ERROR_GRAPH_ABANDONED)
        CT_ENUM_TO_STR(VX_ERROR_GRAPH_SCHEDULED)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_SCOPE)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_NODE)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_GRAPH)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_TYPE)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_VALUE)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_DIMENSION)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_FORMAT)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_LINK)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_REFERENCE)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_MODULE)
        CT_ENUM_TO_STR(VX_ERROR_INVALID_PARAMETERS)
        CT_ENUM_TO_STR(VX_ERROR_OPTIMIZED_AWAY)
        CT_ENUM_TO_STR(VX_ERROR_NO_MEMORY)
        CT_ENUM_TO_STR(VX_ERROR_NO_RESOURCES)
        CT_ENUM_TO_STR(VX_ERROR_NOT_COMPATIBLE)
        CT_ENUM_TO_STR(VX_ERROR_NOT_ALLOCATED)
        CT_ENUM_TO_STR(VX_ERROR_NOT_SUFFICIENT)
        CT_ENUM_TO_STR(VX_ERROR_NOT_SUPPORTED)
        CT_ENUM_TO_STR(VX_ERROR_NOT_IMPLEMENTED)
        CT_ENUM_TO_STR(VX_FAILURE)
        CT_ENUM_TO_STR(VX_SUCCESS)
        default:
            return "Non-standard VX_STATUS code"; //TODO: append numerical code
    };
}

const char* ct_vx_type_to_str(enum vx_type_e type)
{
    switch(type)
    {
        CT_ENUM_TO_STR(VX_TYPE_INVALID)
        CT_ENUM_TO_STR(VX_TYPE_CHAR)
        CT_ENUM_TO_STR(VX_TYPE_INT8)
        CT_ENUM_TO_STR(VX_TYPE_UINT8)
        CT_ENUM_TO_STR(VX_TYPE_INT16)
        CT_ENUM_TO_STR(VX_TYPE_UINT16)
        CT_ENUM_TO_STR(VX_TYPE_INT32)
        CT_ENUM_TO_STR(VX_TYPE_UINT32)
        CT_ENUM_TO_STR(VX_TYPE_INT64)
        CT_ENUM_TO_STR(VX_TYPE_UINT64)
        CT_ENUM_TO_STR(VX_TYPE_FLOAT32)
        CT_ENUM_TO_STR(VX_TYPE_FLOAT64)
        CT_ENUM_TO_STR(VX_TYPE_ENUM)
        CT_ENUM_TO_STR(VX_TYPE_SIZE)
        CT_ENUM_TO_STR(VX_TYPE_DF_IMAGE)
// #ifdef EXPERIMENTAL_PLATFORM_SUPPORTS_16_FLOAT
//         CT_ENUM_TO_STR(VX_TYPE_FLOAT16)
// #endif
        CT_ENUM_TO_STR(VX_TYPE_BOOL)
//      CT_ENUM_TO_STR(VX_TYPE_SCALAR_MAX)
        CT_ENUM_TO_STR(VX_TYPE_RECTANGLE)
        CT_ENUM_TO_STR(VX_TYPE_KEYPOINT)
        CT_ENUM_TO_STR(VX_TYPE_COORDINATES2D)
        CT_ENUM_TO_STR(VX_TYPE_COORDINATES3D)
        CT_ENUM_TO_STR(VX_TYPE_KHRONOS_STRUCT_MAX)
        CT_ENUM_TO_STR(VX_TYPE_USER_STRUCT_START)
        CT_ENUM_TO_STR(VX_TYPE_REFERENCE)
        CT_ENUM_TO_STR(VX_TYPE_CONTEXT)
        CT_ENUM_TO_STR(VX_TYPE_GRAPH)
        CT_ENUM_TO_STR(VX_TYPE_NODE)
        CT_ENUM_TO_STR(VX_TYPE_KERNEL)
        CT_ENUM_TO_STR(VX_TYPE_PARAMETER)
        CT_ENUM_TO_STR(VX_TYPE_DELAY)
        CT_ENUM_TO_STR(VX_TYPE_LUT)
        CT_ENUM_TO_STR(VX_TYPE_DISTRIBUTION)
        CT_ENUM_TO_STR(VX_TYPE_PYRAMID)
        CT_ENUM_TO_STR(VX_TYPE_THRESHOLD)
        CT_ENUM_TO_STR(VX_TYPE_MATRIX)
        CT_ENUM_TO_STR(VX_TYPE_CONVOLUTION)
        CT_ENUM_TO_STR(VX_TYPE_SCALAR)
        CT_ENUM_TO_STR(VX_TYPE_ARRAY)
        CT_ENUM_TO_STR(VX_TYPE_IMAGE)
        CT_ENUM_TO_STR(VX_TYPE_REMAP)
        CT_ENUM_TO_STR(VX_TYPE_ERROR)
        CT_ENUM_TO_STR(VX_TYPE_META_FORMAT)
        CT_ENUM_TO_STR(VX_TYPE_KHRONOS_OBJECT_END)
        default:
            return "Non-standard vx_type_e code"; //TODO: append numerical code
    };
}

int ct_assert_reference_impl(vx_reference ref, enum vx_type_e expect_type, vx_status expect_status,
                             const char* str_ref, const char* func, const char* file, const int line)
{
    vx_status s;
    vx_enum ref_type;

    if (!ref)
    {
        if (expect_status != VX_STATUS_MIN)
        {
            if (expect_type != VX_TYPE_KHRONOS_OBJECT_END)
            {
                CT_RecordFailureAtFormat("Invalid OpenVX object \"%s\""
                    "\n\t\tExpected: %s object"
                    "\n\t\tActual:   NULL", func, file, line, str_ref, ct_vx_type_to_str(expect_type));
            }
            else
            {
                if (expect_status != VX_SUCCESS)
                {
                    return 1; // passed (assume NULL ref as any error)
                }
                CT_RecordFailureAtFormat("Invalid OpenVX reference \"%s\""
                    "\n\t\tExpected: valid object reference"
                    "\n\t\tActual:   NULL", func, file, line, str_ref);
            }
            return 0; //failed
        }
        else
        {
            // if expect_status == VX_STATUS_MIN then we are testing for non-reference
            return 1; //passed
        }
    }

    s = vxQueryReference(ref, VX_REFERENCE_TYPE, &ref_type, sizeof(ref_type));

    if (s == VX_ERROR_INVALID_REFERENCE)
    {
        if (expect_status != VX_STATUS_MIN)
        {
            if (expect_type != VX_TYPE_KHRONOS_OBJECT_END)
            {
                CT_RecordFailureAtFormat("Passed object \"%s\" is not a valid OpenVX reference"
                    "\n\t\tExpected: %s object"
                    "\n\t\tActual:   unknown object", func, file, line, str_ref, ct_vx_type_to_str(expect_type));
            }
            else
            {
                CT_RecordFailureAtFormat("Passed object \"%s\" is not a valid OpenVX object"
                    "\n\t\tExpected: OpenVX object"
                    "\n\t\tActual:   unknown object", func, file, line, str_ref);
            }
            return 0; //failed
        }
        else
        {
            // if expect_status == VX_STATUS_MIN then we are testing for non-reference
            return 1; //passed
        }
    }

    if (s != VX_SUCCESS)
    {
        CT_RecordFailureAtFormat("Error quering the type of \"%s\""
            "\n\t\tExpected: VX_SUCCESS"
            "\n\t\tActual:   %s", func, file, line, str_ref, ct_vx_status_to_str(s));
        return 0; //failed
    }

    if (ref_type == VX_TYPE_ERROR)
    {
        s = vxGetStatus(ref);

        if (s != expect_status)
        {
            CT_RecordFailureAtFormat("Error status of \"%s\" object"
                "\n\t\tExpected: %s"
                "\n\t\tActual:   %s", func, file, line, str_ref, ct_vx_status_to_str(expect_status), ct_vx_status_to_str(s));
            return 0; //failed
        }
    }

    if (expect_type != VX_TYPE_KHRONOS_OBJECT_END) // need to verify type
    {
        if (expect_type != (enum vx_type_e)ref_type)
        {
            CT_RecordFailureAtFormat("Error type of \"%s\" object"
                "\n\t\tExpected: %s"
                "\n\t\tActual:   %s", func, file, line, str_ref, ct_vx_type_to_str(expect_type), ct_vx_type_to_str((enum vx_type_e)ref_type));
            return 0; //failed
        }
    }

    if (expect_status != VX_SUCCESS && ref_type != VX_TYPE_ERROR)
    {
        // we have expected an error object, but got a valid reference
        CT_RecordFailureAtFormat("Error status of \"%s\""
            "\n\t\tExpected: %s"
            "\n\t\tActual:   valid %s object", func, file, line, str_ref, ct_vx_status_to_str(expect_status), ct_vx_type_to_str((enum vx_type_e)ref_type));
        return 0; // failed
    }

    return 1; //passed
}

void ct_fill_image_random_impl(vx_image image, uint64_t* seed, const char* func, const char* file, const int line)
{
    uint64_t rng;
    vx_status status;
    vx_uint32 width  = 0;
    vx_uint32 height = 0;
    vx_size planes = 0;
    vx_df_image format = VX_DF_IMAGE_VIRT;
    vx_rectangle_t rect;
    vx_imagepatch_addressing_t addr;
    uint32_t x, y, p;

    ASSERT_AT(seed != NULL, func, file, line);

    CT_RNG_INIT(rng, *seed);

    ASSERT_EQ_VX_STATUS_AT_(return, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_WIDTH,   &width,   sizeof(width)),  func, file, line);
    ASSERT_EQ_VX_STATUS_AT_(return, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_HEIGHT,  &height,  sizeof(height)), func, file, line);
    ASSERT_EQ_VX_STATUS_AT_(return, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_PLANES,  &planes,  sizeof(planes)), func, file, line);
    ASSERT_EQ_VX_STATUS_AT_(return, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_FORMAT,  &format,  sizeof(format)), func, file, line);

    ASSERT_AT(format != VX_DF_IMAGE_VIRT, func, file, line);

    rect.start_x = rect.start_y = 0;
    rect.end_x = width;
    rect.end_y = height;

    for (p = 0; p < planes; ++p)
    {
        vx_map_id map_id;
        void* base_ptr = 0;
        ASSERT_EQ_VX_STATUS_AT_(return, VX_SUCCESS, vxMapImagePatch(image, &rect, p, &map_id, &addr, &base_ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0), func, file, line);

#define SET_PIXELS(data_type, commands)                                     \
    for (y = 0; y < addr.dim_y; y += addr.step_y)                           \
    {                                                                       \
        for (x = 0; x < addr.dim_x; x += addr.step_x)                       \
        {                                                                   \
            data_type* data = (data_type*)vxFormatImagePatchAddress2d(base_ptr, x, y, &addr); \
            commands                                                        \
        }                                                                   \
    }

        status = VX_SUCCESS;
        if (format == VX_DF_IMAGE_U1)      // 1 plane of 1-bit data
            SET_PIXELS(vx_uint8,
            {
                vx_uint8 offset = x % 8;
                vx_uint8 mask = 1 << offset;
                vx_uint8 rng_val = (vx_uint8)CT_RNG_NEXT_INT(rng, 0, 2) << offset;
                data[0] = (data[0] & ~mask) | rng_val;
            })
        else if (format == VX_DF_IMAGE_U8) // 1 plane of 8-bit data
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_U16) // 1 plane of 16-bit data
            SET_PIXELS(vx_uint16,
            {
                data[0] = (vx_uint16)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_U32) // 1 plane of 32-bit data
            SET_PIXELS(vx_uint32,
            {
                data[0] = (vx_uint32)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_S16) // 1 plane of 16-bit data
            SET_PIXELS(vx_int16,
            {
                data[0] = (vx_int16)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_S32) // 1 plane of 32-bit data
            SET_PIXELS(vx_int32,
            {
                data[0] = (vx_int32)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_RGB) // 1 plane of 24-bit data
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                data[1] = (vx_uint8)CT_RNG_NEXT(rng);
                data[2] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_RGBX) // 1 plane of 32-bit data
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                data[1] = (vx_uint8)CT_RNG_NEXT(rng);
                data[2] = (vx_uint8)CT_RNG_NEXT(rng);
                data[3] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_YUV4) // 3 planes of 8-bit data
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_IYUV) // 3 planes of 8-bit data
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        else if (format == VX_DF_IMAGE_NV12) // 2 planes: one of 8-bit data and one of 16-bit data
        {
            // width must be multiple of 2
            if (p == 0)
                SET_PIXELS(vx_uint8,
                {
                    data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                })
            else if(p == 1)
                SET_PIXELS(vx_uint8,
                {
                    data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                    data[1] = (vx_uint8)CT_RNG_NEXT(rng);
                })
            else
                status = VX_FAILURE;
        }
        else if (format == VX_DF_IMAGE_NV21) // 2 planes: one of 8-bit data and one of 16-bit data
        {
            // width must be multiple of 2
            if (p == 0)
                SET_PIXELS(vx_uint8,
                {
                    data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                })
            else if(p == 1)
                SET_PIXELS(vx_uint8,
                {
                    data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                    data[1] = (vx_uint8)CT_RNG_NEXT(rng);
                })
            else
                status = VX_FAILURE;
        }
        else if (format == VX_DF_IMAGE_UYVY) // 1 plane of 16-bit data
        {
            // width must be multiple of 2
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                data[1] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        }
        else if (format == VX_DF_IMAGE_YUYV) // 1 plane of 16-bit data
        {
            // width must be multiple of 2
            SET_PIXELS(vx_uint8,
            {
                data[0] = (vx_uint8)CT_RNG_NEXT(rng);
                data[1] = (vx_uint8)CT_RNG_NEXT(rng);
            })
        }
        else
            status = VX_FAILURE;
#undef SET_PIXELS

        *seed = rng; // return new value of random number generator

        if (status != VX_SUCCESS)
        {
            vxUnmapImagePatch(image, map_id); // empty commit to abort transaction
            FAIL_AT("ENGINE: Unknown or broken vx_image format: %.4s", func, file, line, &format);
        }
        ASSERT_EQ_VX_STATUS_AT_(return, VX_SUCCESS, vxUnmapImagePatch(image, map_id), func, file, line);
    } /* for planes */
}

vx_image ct_clone_image_impl(vx_image image, vx_graph graph, const char* func, const char* file, const int line)
{
#define CLONE_FAILED() CT_RecordFailureAt("ENGINE: Unable to make a clone of vx_image", func, file, line)
    vx_status status;
    vx_uint32 width  = 0;
    vx_uint32 height = 0;
    vx_size planes = 0;
    vx_df_image format = 0;
    vx_rectangle_t rect;
    void *base_ptr_src = 0;
    void *base_ptr_dst = 0;
    vx_uint32 p;
    vx_context context = 0;
    vx_image clone = 0;
    int is_virtual = 0;

    if (!image) return NULL; //OK
    if (vxGetStatus((vx_reference)image) != VX_SUCCESS) { CLONE_FAILED(); return NULL; }

    context = vxGetContext((vx_reference)image);
    if (vxGetStatus((vx_reference)context) != VX_SUCCESS) { CLONE_FAILED(); return NULL; }

    status = vxQueryImage(image, VX_IMAGE_WIDTH,  &width,  sizeof(width));
    if (status != VX_SUCCESS)  { CLONE_FAILED(); return NULL; }
    status = vxQueryImage(image, VX_IMAGE_HEIGHT, &height, sizeof(height));
    if (status != VX_SUCCESS)  { CLONE_FAILED(); return NULL; }
    status = vxQueryImage(image, VX_IMAGE_FORMAT, &format, sizeof(format));
    if (status != VX_SUCCESS)  { CLONE_FAILED(); return NULL; }

    if (format == VX_DF_IMAGE_VIRT || width == 0 || height == 0) is_virtual = 1;

    // test if still virtual
    if (!is_virtual)
    {
        vx_imagepatch_addressing_t addr_src = VX_IMAGEPATCH_ADDR_INIT;
        vx_map_id map_id;
        rect.start_x = rect.start_y = 0;
        rect.end_x = width; rect.end_y = height;
        status = vxMapImagePatch(image, &rect, 0, &map_id, &addr_src, &base_ptr_src, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);

        if (status == VX_ERROR_OPTIMIZED_AWAY)
        {
            is_virtual = 1;
        }
        else
        {
            if (status != VX_SUCCESS) { CLONE_FAILED(); return NULL; }
            status = vxUnmapImagePatch(image, map_id);
            if (status != VX_SUCCESS) { CLONE_FAILED(); return NULL; }
        }
    }

    if (is_virtual)
    {
        if (graph == 0 || vxGetStatus((vx_reference)graph) != VX_SUCCESS)
        {
            CT_RecordFailureAt("ENGINE: Unable to make a clone of vx_image without valid graph object", func, file, line);
            return NULL;
        }

        clone = vxCreateVirtualImage(graph, width, height, format);
        if (vxGetStatus((vx_reference)clone) != VX_SUCCESS) { CLONE_FAILED(); return NULL; }
    }
    else
    {
        clone = vxCreateImage(context, width, height, format);
        if (vxGetStatus((vx_reference)clone) != VX_SUCCESS) { CLONE_FAILED(); return NULL; }

        status = vxQueryImage(image, VX_IMAGE_PLANES, &planes, sizeof(planes));
        if (status != VX_SUCCESS)  { CLONE_FAILED(); return NULL; }

        // TODO: use vxGetValidRegionImage
        rect.start_x = rect.start_y = 0;
        rect.end_x = width;
        rect.end_y = height;

#if defined OPENVX_PLANE_COPYING_VARIANT1
        for (p = 0; p < planes; ++p)
        {
            vx_imagepatch_addressing_t addr_src = VX_IMAGEPATCH_ADDR_INIT;
            vx_imagepatch_addressing_t addr_dst = VX_IMAGEPATCH_ADDR_INIT;
            vx_status status1;
            base_ptr_src = base_ptr_dst = 0;
            status = vxAccessImagePatch(clone, &rect, p, &addr_dst, &base_ptr_dst, VX_WRITE_ONLY);
            if (status != VX_SUCCESS) { CLONE_FAILED(); return NULL; }
            status = vxAccessImagePatch(image, &rect, p, &addr_src, &base_ptr_src, VX_READ_ONLY);
            if (status != VX_SUCCESS) { CLONE_FAILED(); vxReleaseImage(&clone); return NULL; }

            // UNDEFINED BEHAVIOR: pass pointer obtained for one image to commit on another image
            status  = vxCommitImagePatch(clone, &rect, p, &addr_src, base_ptr_src);
            status1 = vxCommitImagePatch(image, 0, p, &addr_dst, base_ptr_dst);
            if (status1 != VX_SUCCESS || status != VX_SUCCESS)
            {
                CLONE_FAILED(); vxReleaseImage(&clone); return NULL;
            }
        }
#elif defined OPENVX_PLANE_COPYING_VARIANT2
        for (p = 0; p < planes; ++p)
        {
            vx_imagepatch_addressing_t addr_src = VX_IMAGEPATCH_ADDR_INIT;
            vx_status status1;
            base_ptr_src = 0;
            status = vxAccessImagePatch(image, &rect, p, &addr_src, &base_ptr_src, VX_READ_ONLY);
            if (status != VX_SUCCESS) { CLONE_FAILED(); vxReleaseImage(&clone); return NULL; }

            // 1) passing non-zero address to vxAccessImagePatch means that we ask to use our buffer
            // 2) UNDEFINED BEHAVIOR: assuming that VX_WRITE_ONLY with external buffer does not modify the buffer data
            // 3) assuming that addressing structure is not changed or filled with the same values;
            //    actually existense of vxComputeImagePatchSize almost guarantee that this assumption is correct
            status = vxAccessImagePatch(clone, &rect, p, &addr_src, &base_ptr_src, VX_WRITE_ONLY);
            if (status != VX_SUCCESS) { CLONE_FAILED(); return NULL; }

            // commit using "externally" allocated buffer
            // implementation has to copy data internally
            // implementation must not release the buffer
            status  = vxCommitImagePatch(clone, &rect, p, &addr_src, base_ptr_src);

            // commit with pointer obtained from vxAccessImagePatch for the same image
            // implementation has to decrement image refcounter and recycle the buffer
            status1 = vxCommitImagePatch(image, 0, p, &addr_src, base_ptr_src);
            if (status1 != VX_SUCCESS || status != VX_SUCCESS)
            {
                CLONE_FAILED(); vxReleaseImage(&clone); return NULL;
            }
        }
#else
        for (p = 0; p < planes; ++p)
        {
            vx_imagepatch_addressing_t addr_src = VX_IMAGEPATCH_ADDR_INIT;
            vx_imagepatch_addressing_t addr_dst = VX_IMAGEPATCH_ADDR_INIT;
            vx_map_id map_id_src;
            vx_map_id map_id_dst;

            vx_uint32 w, h, x, y, k;
            vx_uint32 elem_sz = 0;
            switch(format)
            {
                case VX_DF_IMAGE_U1:
                case VX_DF_IMAGE_U8:
                case VX_DF_IMAGE_YUV4:
                case VX_DF_IMAGE_IYUV:
                    elem_sz = 1;
                    break;
                case VX_DF_IMAGE_S16:
                case VX_DF_IMAGE_U16:
                case VX_DF_IMAGE_UYVY:
                case VX_DF_IMAGE_YUYV:
                    elem_sz = 2;
                    break;
                case VX_DF_IMAGE_RGB:
                    elem_sz = 3;
                    break;
                case VX_DF_IMAGE_S32:
                case VX_DF_IMAGE_U32:
                case VX_DF_IMAGE_RGBX:
                    elem_sz = 4;
                    break;
                case VX_DF_IMAGE_NV12:
                case VX_DF_IMAGE_NV21:
                    if (p == 0)
                        elem_sz = 1;
                    else if (p == 1)
                        elem_sz = 2;
                    break;
                default:
                    /* unknown format*/
                    elem_sz = 0;
                    break;
            };
            if (elem_sz == 0)
            {
                CLONE_FAILED();
                vxReleaseImage(&clone);
                return NULL;
            }

            base_ptr_src = base_ptr_dst = 0;
            status = vxMapImagePatch(clone, &rect, p, &map_id_dst, &addr_dst, &base_ptr_dst, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0);
            if (status != VX_SUCCESS) { CLONE_FAILED(); return NULL; }

            status = vxMapImagePatch(image, &rect, p, &map_id_src, &addr_src, &base_ptr_src, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);
            if (status != VX_SUCCESS) { CLONE_FAILED(); vxReleaseImage(&clone); return NULL; }

            h = addr_src.dim_y / addr_src.step_y;
            w = addr_src.dim_x / addr_src.step_x;

            if (h != addr_dst.dim_y / addr_dst.step_y || w != addr_dst.dim_x / addr_dst.step_x)
            {
                // everything is bad
                CLONE_FAILED();
                vxUnmapImagePatch(clone, map_id_dst);
                vxUnmapImagePatch(image, map_id_src);
                vxReleaseImage(&clone);
                return NULL;
            }

            for (y = 0; y < h; y++)
            {
                int j_src = y * addr_src.stride_y * addr_src.step_y * addr_src.scale_y / VX_SCALE_UNITY;
                int j_dst = y * addr_dst.stride_y * addr_dst.step_y * addr_dst.scale_y / VX_SCALE_UNITY;

                for (x = 0; x < w; x++)
                {
                    int i_src, i_dst, src_offset = 0, dst_offset = 0;
                    if (format == VX_DF_IMAGE_U1)
                    {
                        int x_bits_src = x * addr_src.stride_x_bits * addr_src.step_x * addr_src.scale_x / VX_SCALE_UNITY;
                        int x_bits_dst = x * addr_dst.stride_x_bits * addr_dst.step_x * addr_dst.scale_x / VX_SCALE_UNITY;
                        i_src = x_bits_src / 8;
                        i_dst = x_bits_dst / 8;
                        src_offset = x_bits_src % 8;
                        dst_offset = x_bits_dst % 8;
                    }
                    else
                    {
                        i_src = x * addr_src.stride_x * addr_src.step_x * addr_src.scale_x / VX_SCALE_UNITY;
                        i_dst = x * addr_dst.stride_x * addr_dst.step_x * addr_dst.scale_x / VX_SCALE_UNITY;
                    }

                    vx_uint8 *psrc = (vx_uint8*)(((vx_uint8 *)base_ptr_src) + j_src + i_src);
                    vx_uint8 *pdst = (vx_uint8*)(((vx_uint8 *)base_ptr_dst) + j_dst + i_dst);

                    for(k = 0; k < elem_sz; ++k)
                    {
                        if (format == VX_DF_IMAGE_U1)
                        {
                            vx_uint8 src_val = (psrc[k] & (1 << src_offset)) >> src_offset;
                            pdst[k] = (pdst[k] & ~(1 << dst_offset)) | (src_val << dst_offset);  // Set target pixel
                        }
                        else
                        {
                            pdst[k] = psrc[k];
                        }
                    }
                }
            }

            status = vxUnmapImagePatch(image, map_id_src);
            if (status != VX_SUCCESS) { CLONE_FAILED(); vxReleaseImage(&clone); return NULL; }

            status = vxUnmapImagePatch(clone, map_id_dst);
            if (status != VX_SUCCESS) { CLONE_FAILED(); vxReleaseImage(&clone); return NULL; }
        }
#endif
    }

    // copy remaining attributes
    {
        vx_enum space;
        if (vxQueryImage(image, VX_IMAGE_SPACE, &space, sizeof(space)) != VX_SUCCESS)
        {
            CLONE_FAILED(); vxReleaseImage(&clone); return NULL;
        }
        if (vxSetImageAttribute(clone, VX_IMAGE_SPACE, &space, sizeof(space)) != VX_SUCCESS)
        {
            CLONE_FAILED(); vxReleaseImage(&clone); return NULL;
        }
    }

    return clone;
#undef CLONE_FAILED
}

static vx_context g_vx_context = 0;

static void VX_CALLBACK log_callback(vx_context context, vx_reference ref, vx_status status, const vx_char* str)
{
#if 0
    printf("LOG entry for object %p: %s\n", ref, str);
#endif
}

static vx_context ct_create_vx_context()
{
    if (g_vx_context)
    {
        return g_vx_context;
    }
    else
    {
        vx_context ctx = vxCreateContext();
        if (vxGetStatus((vx_reference)ctx) == VX_SUCCESS)
            vxRegisterLogCallback(ctx, log_callback, vx_true_e);

        return ctx;
    }
    return g_vx_context;
}

void ct_create_global_vx_context()
{
    g_vx_context = ct_create_vx_context();
}

void ct_release_global_vx_context()
{
    if (g_vx_context)
    {
        vxReleaseContext(&g_vx_context);
        ASSERT(g_vx_context == 0);
    }
}

static void ct_teardown_vx_context(void/*CT_VXContext*/ **context_)
{
    CT_VXContext* context = (CT_VXContext*)*context_;
    if (context == NULL)
        return;

    if (!g_vx_context && context->vx_context_)
    {
        if (!CT_HasFailure())
        {
            vx_uint32 dangling_refs_count, modules, kernels;
            EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryContext(context->vx_context_, VX_CONTEXT_REFERENCES, &dangling_refs_count, sizeof(dangling_refs_count)));
            EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryContext(context->vx_context_, VX_CONTEXT_MODULES, &modules, sizeof(modules)));
            EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryContext(context->vx_context_, VX_CONTEXT_UNIQUE_KERNELS, &kernels, sizeof(kernels)));

            // The specification needs to be clarified. Implementations may have a different interpretation of what
            // is an 'active reference'. The number of active references may or may not be 0 just after context creation.
            dangling_refs_count -= context->vx_context_base_references_;

            // The specification needs to be clarified. An implementation may or may not consider kernel objects
            // that are not referenced by the application (but that are still alive since a kernels exist until
            // explicitly removed) as 'active references'. In case the implementation does, an aditionnal subtraction
            // is needed.
            if ( ((modules != context->vx_context_base_modules_) ||
                  (kernels != context->vx_context_base_kernels_)) &&
                 (dangling_refs_count > 0))
            {
                dangling_refs_count -= kernels - context->vx_context_base_kernels_;
            }

            EXPECT_EQ_INT(0, dangling_refs_count);
        }
        vxReleaseContext(&context->vx_context_);
        ASSERT(context->vx_context_ == 0);
    }

    ct_free_mem(context);
}

void* ct_setup_vx_context()
{
    CT_VXContext* context = (CT_VXContext*)ct_alloc_mem(sizeof(CT_VXContext));
    context->vx_context_ = ct_create_vx_context();
    ASSERT_VX_OBJECT_({ct_free_mem(context); return 0;}, context->vx_context_, VX_TYPE_CONTEXT);

    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryContext(context->vx_context_, VX_CONTEXT_REFERENCES,
        &context->vx_context_base_references_, sizeof(context->vx_context_base_references_)));
    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryContext(context->vx_context_, VX_CONTEXT_MODULES,
        &context->vx_context_base_modules_, sizeof(context->vx_context_base_modules_)));
    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryContext(context->vx_context_, VX_CONTEXT_UNIQUE_KERNELS,
        &context->vx_context_base_kernels_, sizeof(context->vx_context_base_kernels_)));

    CT_RegisterForGarbageCollection(context, ct_teardown_vx_context, CT_GC_OBJECT);
    return context;
}

vx_image ct_create_similar_image_impl(vx_image image, const char* func, const char* file, const int line)
{
    vx_uint32 width  = 0;
    vx_uint32 height = 0;
    vx_df_image format = VX_DF_IMAGE_VIRT;
    vx_image new_image = 0;

    vx_context context = vxGetContext((vx_reference)image);
    ASSERT_VX_OBJECT_AT_(return 0, context, VX_TYPE_CONTEXT, func, file, line);

    ASSERT_EQ_VX_STATUS_AT_(return 0, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_WIDTH,   &width,   sizeof(width)),  func, file, line);
    ASSERT_EQ_VX_STATUS_AT_(return 0, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_HEIGHT,  &height,  sizeof(height)), func, file, line);
    ASSERT_EQ_VX_STATUS_AT_(return 0, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_FORMAT,  &format,  sizeof(format)), func, file, line);

    new_image = vxCreateImage(context, width, height, format);
    ASSERT_VX_OBJECT_AT_(return 0, new_image, VX_TYPE_IMAGE, func, file, line);

    return new_image;
}

vx_image ct_create_similar_image_with_format_impl(vx_image image, vx_df_image format, const char* func, const char* file, const int line)
{
    vx_uint32 width  = 0;
    vx_uint32 height = 0;
    vx_image new_image = 0;

    vx_context context = vxGetContext((vx_reference)image);
    ASSERT_VX_OBJECT_AT_(return 0, context, VX_TYPE_CONTEXT, func, file, line);

    ASSERT_EQ_VX_STATUS_AT_(return 0, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_WIDTH,   &width,   sizeof(width)),  func, file, line);
    ASSERT_EQ_VX_STATUS_AT_(return 0, VX_SUCCESS, vxQueryImage(image, VX_IMAGE_HEIGHT,  &height,  sizeof(height)), func, file, line);

    new_image = vxCreateImage(context, width, height, format);
    ASSERT_VX_OBJECT_AT_(return 0, new_image, VX_TYPE_IMAGE, func, file, line);

    return new_image;
}


vx_status ct_dump_vx_image_info(vx_image image)
{
    vx_uint32 width  = 0;
    vx_uint32 height = 0;
    vx_size planes = 0;
    vx_df_image format = 0;

    VX_CALL_RET(vxGetStatus((vx_reference)image));

    VX_CALL_RET(vxQueryImage(image, VX_IMAGE_WIDTH,  &width,  sizeof(width)));
    VX_CALL_RET(vxQueryImage(image, VX_IMAGE_HEIGHT, &height, sizeof(height)));
    VX_CALL_RET(vxQueryImage(image, VX_IMAGE_FORMAT, &format, sizeof(format)));
    VX_CALL_RET(vxQueryImage(image, VX_IMAGE_PLANES, &planes, sizeof(planes)));

    printf("Image %p DF_IMAGE(%.*s): %dx%d (%d planes)\n",
            image, (int)sizeof(format), (char*)&format,
            width, height, (int)planes);

    return VX_SUCCESS;
}

uint32_t ct_floor_u32_no_overflow(float v)
{
    return (uint32_t)(v);
}

// Integer division with rounding towards minus infinity
int ct_div_floor(int x, int y) {
    int q = x / y;
    int r = x % y;
    if ( (r != 0) && ((r < 0) != (y < 0)) )
        --q;
    return q;
}

uint8_t ct_clamp_8u(int32_t v)
{
    if (v >= 255)
        return 255;
    if (v <= 0)
        return 0;
    return (uint8_t)v;
}

float ct_log_rng(uint64_t* rng, float minlog2, float maxlog2)
{
    float a = (float)CT_RNG_NEXT_REAL(*rng, minlog2, maxlog2);
    return expf(a*0.6931471805599453f);
}

int ct_roundf(float val)
{
    return (int)floor(val + 0.5);
}

typedef union ct_scalar_val
{
    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_int64  u64;
    vx_float32 f32;
    vx_float64 f64;
    vx_df_image  fcc;
    vx_enum    enm;
    vx_size    size;
    vx_bool    boolean;
} ct_scalar_val;


int ct_scalar_as_int(vx_scalar val)
{
    vx_enum sctype = 0;
    ct_scalar_val scval;
    int ival = -1;

    vxQueryScalar(val, VX_SCALAR_TYPE, &sctype, sizeof(sctype));
    vxCopyScalar(val, &scval, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);

    if( sctype == VX_TYPE_CHAR )
        ival = scval.chr;
    else if( sctype == VX_TYPE_INT8 )
        ival = scval.s08;
    else if( sctype == VX_TYPE_UINT8 )
        ival = scval.u08;
    else if( sctype == VX_TYPE_INT16 )
        ival = scval.s16;
    else if( sctype == VX_TYPE_UINT16 )
        ival = scval.u16;
    else if( sctype == VX_TYPE_INT32 )
        ival = scval.s32;
    else if( sctype == VX_TYPE_UINT32 )
        ival = (int)scval.u32;
    else if( sctype == VX_TYPE_INT64 )
        ival = (int)scval.s64;
    else if( sctype == VX_TYPE_UINT64 )
        ival = (int)scval.u64;
    else if( sctype == VX_TYPE_FLOAT32 )
        ival = ct_roundf(scval.f32);
    else if( sctype == VX_TYPE_FLOAT64 )
        ival = ct_roundf((float)scval.f64);
    else if( sctype == VX_TYPE_DF_IMAGE )
        ival = (int)scval.fcc;
    else if( sctype == VX_TYPE_ENUM )
        ival = ct_roundf((float)scval.enm);
    else if( sctype == VX_TYPE_SIZE )
        ival = ct_roundf((float)scval.size);
    else if( sctype == VX_TYPE_BOOL )
        ival = scval.boolean == vx_true_e;
    else
    {
        CT_ADD_FAILURE("Can not read int from scalar of type %d", (int)sctype);
    }

    return ival;
}

vx_scalar ct_scalar_from_int(vx_context ctx, vx_enum sctype, int ival)
{
    ct_scalar_val scval;

    if( sctype == VX_TYPE_CHAR )
        scval.chr = (char)ival;
    else if( sctype == VX_TYPE_INT8 )
        scval.s08 = (vx_int8)ival;
    else if( sctype == VX_TYPE_UINT8 )
        scval.u08 = (vx_uint8)ival;
    else if( sctype == VX_TYPE_INT16 )
        scval.s16 = (vx_int16)ival;
    else if( sctype == VX_TYPE_UINT16 )
        scval.u16 = (vx_uint16)ival;
    else if( sctype == VX_TYPE_INT32 )
        scval.s32 = (vx_int32)ival;
    else if( sctype == VX_TYPE_UINT32 )
        scval.u32 = (vx_uint32)ival;
    else if( sctype == VX_TYPE_INT64 )
        scval.s64 = (vx_int64)ival;
    else if( sctype == VX_TYPE_UINT64 )
        scval.u64 = (vx_uint64)ival;
    else if( sctype == VX_TYPE_FLOAT32 )
        scval.f32 = (vx_float32)ival;
    else if( sctype == VX_TYPE_FLOAT64 )
        scval.f64 = (vx_float64)ival;
    else if( sctype == VX_TYPE_DF_IMAGE )
        scval.fcc = (vx_df_image)ival;
    else if( sctype == VX_TYPE_ENUM )
        scval.enm = (vx_enum)ival;
    else if( sctype == VX_TYPE_SIZE )
        scval.size = (vx_size)ival;
    else if( sctype == VX_TYPE_BOOL )
        scval.boolean = ival != 0 ? vx_true_e : vx_false_e;
    else
    {
        CT_ADD_FAILURE("Can not read int from scalar of type %d", (int)sctype);
        return 0;
    }

    return vxCreateScalar(ctx, sctype, &scval);
}

vx_enum ct_read_array(vx_array src, void** dst, vx_size* _capacity_bytes,
                      vx_size* _arrsize, vx_size* _arrcap )
{
    vx_size i;
    vx_size arrsize_bytes;
    vx_size arrcap = 0;
    vx_size arrsize  = 0;
    vx_size itemsize = 0;
    vx_size stride   = 0;
    vx_enum itemtype = 0;
    vx_map_id map_id;
    char* ptr = 0;

    vxQueryArray(src, VX_ARRAY_ITEMTYPE, &itemtype, sizeof(itemtype));
    vxQueryArray(src, VX_ARRAY_CAPACITY, &arrcap, sizeof(arrcap));
    vxQueryArray(src, VX_ARRAY_NUMITEMS, &arrsize, sizeof(arrsize));
    vxQueryArray(src, VX_ARRAY_ITEMSIZE, &itemsize, sizeof(itemsize));

    if(_arrsize)
        *_arrsize = arrsize;
    if(_arrcap)
        *_arrcap = arrcap;

    if(arrsize == 0)
        return itemtype;

    arrsize_bytes = arrsize*itemsize;
    if( _capacity_bytes == 0 || arrsize_bytes >= *_capacity_bytes )
    {
        if(*dst)
            ct_free_mem(*dst);

        *dst = ct_alloc_mem(arrsize_bytes);

        if (_capacity_bytes)
            *_capacity_bytes = arrsize_bytes;
    }

    vxMapArrayRange(src, 0, arrsize, &map_id, &stride, (void**)&ptr, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);

    if( stride == itemsize )
        memcpy(*dst, ptr, arrsize_bytes);
    else
    {
        for( i = 0; i < arrsize; i++ )
            memcpy((char*)(*dst) + i*itemsize, ptr + i*stride, itemsize);
    }

    vxUnmapArrayRange(src, map_id);

    return itemtype;
}

void ct_update_progress(int i, int niters)
{
    if( i == 0 )
    {
        printf("[ ");
    }
    if( (i+1)%(niters/8) == 0 )
    {
        putchar('*');
        fflush(stdout);
    }
    if( i == niters-1 )
    {
        printf(" ]\n");
    }
}


static int check_any_size = 0;
int ct_check_any_size()
{
    return check_any_size;
}

void ct_set_check_any_size(int flag)
{
    check_any_size = flag;
}

void ct_destroy_vx_context(void **pContext)
{
    vxReleaseContext((vx_context *)pContext);
    *pContext = NULL;
}

const char *ct_get_test_file_path()
{
    const char *env = getenv("VX_TEST_DATA_PATH");
    if (env == NULL)
    {
        /* Look in the current directory */
        return ".";
    }
    return env;
}

void ct_delay_ms(uint32_t ms)
{
#if defined (_WIN32)
    Sleep(ms);
#else
    usleep(ms * 1000);
#endif
}