/*

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

#if defined OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION

#include "test_engine/test.h"

#include <VX/vx.h>
#include <VX/vxu.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>

static int get_yuv_params(CT_Image img, uint8_t** ptrY, uint8_t** ptrU, uint8_t** ptrV,
                           uint32_t* strideY, uint32_t* deltaY,
                           uint32_t* strideC, uint32_t* deltaC,
                           uint32_t* shiftX, uint32_t* shiftY, int* code)
{
    int format = img->format;
    int is_yuv = 0;
    uint32_t stride = ct_stride_bytes(img);
    uint32_t height = img->height;

    *ptrY = img->data.y;
    *strideY = *strideC = stride;
    *deltaY = *deltaC = 1;
    *shiftX = *shiftY = 0;

    if( format == VX_DF_IMAGE_YUV4 )
    {
        *ptrU = *ptrY + stride*height;
        *ptrV = *ptrU + stride*height;
        *shiftX = *shiftY = 0;
        is_yuv = 1;
    }
    else if( format == VX_DF_IMAGE_IYUV )
    {
        *ptrU = *ptrY + stride*height;
        *ptrV = *ptrU + (stride*height)/4;
        *strideC = stride/2;
        *shiftX = *shiftY = 1;
        is_yuv = 1;
    }
    else if( format == VX_DF_IMAGE_NV12 || format == VX_DF_IMAGE_NV21 )
    {
        if( format == VX_DF_IMAGE_NV12 )
        {
            *ptrU = *ptrY + stride*height;
            *ptrV = *ptrU + 1;
        }
        else
        {
            *ptrV = *ptrY + stride*height;
            *ptrU = *ptrV + 1;
        }
        *deltaC = 2;
        *shiftX = *shiftY = 1;
        is_yuv = 1;
    }
    else if( format == VX_DF_IMAGE_YUYV || format == VX_DF_IMAGE_UYVY )
    {
        if( format == VX_DF_IMAGE_YUYV )
        {
            *ptrU = *ptrY + 1;
        }
        else
        {
            *ptrU = *ptrY;
            *ptrY = *ptrU + 1;
        }
        *ptrV = *ptrU + 2;
        *deltaY = 2;
        *deltaC = 4;
        *shiftX = 1;
        *shiftY = 0;
        is_yuv = 1;
    }
    *code = *shiftX == 0 ? 444 : *shiftY == 0 ? 422 : 420;
    return is_yuv;
}

static void rgb2yuv_bt709(uint8_t r, uint8_t g, uint8_t b, uint8_t* y, uint8_t* u, uint8_t* v)
{
    int yval = (int)(r*0.2126f + g*0.7152f + b*0.0722f + 0.5f);
    int uval = (int)(-r*0.1146f - g*0.3854 + b*0.5f + 128.5f);
    int vval = (int)(r*0.5f - g*0.4542f - b*0.0458f + 128.5f);
    *y = CT_CAST_U8(yval);
    *u = CT_CAST_U8(uval);
    *v = CT_CAST_U8(vval);
}

static void yuv2rgb_bt709(uint8_t y, uint8_t u, uint8_t v, uint8_t* r, uint8_t* g, uint8_t* b)
{
    int rval = (int)(y + 1.5748f*(v-128) + 0.5f);
    int gval = (int)(y - 0.1873f*(u-128) - 0.4681f*(v-128) + 0.5f);
    int bval = (int)(y + 1.8556f*(u-128) + 0.5f);
    *r = CT_CAST_U8(rval);
    *g = CT_CAST_U8(gval);
    *b = CT_CAST_U8(bval);
}

static void reference_colorconvert(CT_Image src, CT_Image dst)
{
    uint32_t x, y, width, height, srcstride, dststride;
    int srcformat = src->format;
    int dstformat = dst->format;
    uint8_t *srcptrY=0, *srcptrU=0, *srcptrV=0;
    uint8_t *dstptrY=0, *dstptrU=0, *dstptrV=0;
    uint32_t srcstrideY=0, srcdeltaY=1, srcstrideC=0, srcdeltaC=1;
    uint32_t dststrideY=0, dstdeltaY=1, dststrideC=0, dstdeltaC=1;
    uint32_t srcshiftX = 1, srcshiftY = 1;
    uint32_t dstshiftX = 1, dstshiftY = 1;
    int srcYUV, dstYUV;
    int srccode=0, dstcode=0;

    ASSERT(src && dst);
    ASSERT(src->width > 0 && src->height > 0 &&
           src->width == dst->width && src->height == dst->height);

    width = src->width;
    height = src->height;
    srcstride = ct_stride_bytes(src);
    dststride = ct_stride_bytes(dst);

    srcYUV = get_yuv_params(src, &srcptrY, &srcptrU, &srcptrV, &srcstrideY,
                            &srcdeltaY, &srcstrideC, &srcdeltaC,
                            &srcshiftX, &srcshiftY, &srccode);
    dstYUV = get_yuv_params(dst, &dstptrY, &dstptrU, &dstptrV, &dststrideY,
                            &dstdeltaY, &dststrideC, &dstdeltaC,
                            &dstshiftX, &dstshiftY, &dstcode);

    if( srcformat == VX_DF_IMAGE_RGB || srcformat == VX_DF_IMAGE_RGBX )
    {
        int scn = ct_channels(srcformat);
        if( dstformat == VX_DF_IMAGE_RGB || dstformat == VX_DF_IMAGE_RGBX )
        {
            int dcn = ct_channels(dstformat);

            for( y = 0; y < height; y++ )
            {
                const uint8_t* srcptr = (const uint8_t*)(src->data.y + y*srcstride);
                uint8_t* dstptr = (uint8_t*)(dst->data.y + y*dststride);
                for( x = 0; x < width; x++, srcptr += scn, dstptr += dcn )
                {
                    dstptr[0] = srcptr[0];
                    dstptr[1] = srcptr[1];
                    dstptr[2] = srcptr[2];
                    if(dcn == 4)
                        dstptr[3] = 255;
                }
            }

        }
        else if( dstYUV )
        {
            if( dstcode == 444 )
            {
                for( y = 0; y < height; y++ )
                {
                    const uint8_t* srcptr = (const uint8_t*)(src->data.y + y*srcstride);
                    for( x = 0; x < width; x++, srcptr += scn )
                    {
                        rgb2yuv_bt709(srcptr[0], srcptr[1], srcptr[2],
                                      dstptrY + dststrideY*y + dstdeltaY*x,
                                      dstptrU + dststrideC*y + dstdeltaC*x,
                                      dstptrV + dststrideC*y + dstdeltaC*x);
                    }
                }
            }
            else if( dstcode == 422 )
            {
                for( y = 0; y < height; y++ )
                {
                    const uint8_t* srcptr = (const uint8_t*)(src->data.y + y*srcstride);
                    for( x = 0; x < width; x += 2, srcptr += scn*2 )
                    {
                        uint8_t u0 = 0, v0 = 0, u1 = 0, v1 = 0;
                        rgb2yuv_bt709(srcptr[0], srcptr[1], srcptr[2],
                                      dstptrY + dststrideY*y + dstdeltaY*x, &u0, &v0);
                        rgb2yuv_bt709(srcptr[scn], srcptr[scn+1], srcptr[scn+2],
                                      dstptrY + dststrideY*y + dstdeltaY*(x+1), &u1, &v1);
                        dstptrU[dststrideC*y + dstdeltaC*(x/2)] = (uint8_t)((u0 + u1) >> 1);
                        dstptrV[dststrideC*y + dstdeltaC*(x/2)] = (uint8_t)((v0 + v1) >> 1);
                    }
                }
            }
            else if( dstcode == 420 )
            {
                for( y = 0; y < height; y += 2 )
                {
                    const uint8_t* srcptr = (const uint8_t*)(src->data.y + y*srcstride);
                    for( x = 0; x < width; x += 2, srcptr += scn*2 )
                    {
                        uint8_t u[4], v[4];
                        rgb2yuv_bt709(srcptr[0], srcptr[1], srcptr[2],
                                      dstptrY + dststrideY*y + dstdeltaY*x, &u[0], &v[0]);
                        rgb2yuv_bt709(srcptr[scn], srcptr[scn+1], srcptr[scn+2],
                                      dstptrY + dststrideY*y + dstdeltaY*(x+1), &u[1], &v[1]);
                        rgb2yuv_bt709(srcptr[srcstride+0], srcptr[srcstride+1], srcptr[srcstride+2],
                                      dstptrY + dststrideY*(y+1) + dstdeltaY*x, &u[2], &v[2]);
                        rgb2yuv_bt709(srcptr[srcstride+scn], srcptr[srcstride+scn+1], srcptr[srcstride+scn+2],
                                      dstptrY + dststrideY*(y+1) + dstdeltaY*(x+1), &u[3], &v[3]);
                        dstptrU[dststrideC*(y/2) + dstdeltaC*(x/2)] = (uint8_t)((u[0] + u[1] + u[2] + u[3]) >> 2);
                        dstptrV[dststrideC*(y/2) + dstdeltaC*(x/2)] = (uint8_t)((v[0] + v[1] + v[2] + v[3]) >> 2);
                    }
                }
            }
        }
    }
    else if( srcYUV )
    {
        if( dstformat == VX_DF_IMAGE_RGB || dstformat == VX_DF_IMAGE_RGBX )
        {
            int dcn = ct_channels(dstformat);

            for( y = 0; y < height; y++ )
            {
                uint8_t* dstptr = (uint8_t*)(dst->data.y + y*dststride);
                for( x = 0; x < width; x++, dstptr += dcn )
                {
                    int xc = x >> srcshiftX, yc = y >> srcshiftY;
                    yuv2rgb_bt709(srcptrY[srcstrideY*y + srcdeltaY*x],
                                  srcptrU[srcstrideC*yc + srcdeltaC*xc],
                                  srcptrV[srcstrideC*yc + srcdeltaC*xc],
                                  dstptr, dstptr + 1, dstptr + 2);
                    if( dcn == 4 )
                        dstptr[3] = 255;
                }
            }
        }
        else if( dstYUV )
        {
            if( srccode <= dstcode )
            {
                // if both src and dst are YUV formats and
                // the source image chroma resolution
                // is smaller then we just replicate the chroma components
                for( y = 0; y < height; y++ )
                {
                    for( x = 0; x < width; x++ )
                    {
                        int dstYC = y >> dstshiftY, dstXC = x >> dstshiftX;
                        int srcYC = y >> srcshiftY, srcXC = x >> srcshiftX;
                        dstptrY[dststrideY*y + dstdeltaY*x] = srcptrY[srcstrideY*y + srcdeltaY*x];
                        dstptrU[dststrideC*dstYC + dstdeltaC*dstXC] = srcptrU[srcstrideC*srcYC + srcdeltaC*srcXC];
                        dstptrV[dststrideC*dstYC + dstdeltaC*dstXC] = srcptrV[srcstrideC*srcYC + srcdeltaC*srcXC];
                    }
                }
            }
            else if( srccode == 422 && dstcode == 420 )
            {
                // if both src and dst are YUV formats and
                // the source image chroma resolution
                // is larger then we have to average chroma samples
                for( y = 0; y < height; y += 2 )
                {
                    for( x = 0; x < width; x++ )
                    {
                        int dstYC = y >> dstshiftY, dstXC = x >> dstshiftX;
                        int srcYC = y >> srcshiftY, srcXC = x >> srcshiftX;
                        dstptrY[dststrideY*y + dstdeltaY*x] = srcptrY[srcstrideY*y + srcdeltaY*x];
                        dstptrY[dststrideY*(y+1) + dstdeltaY*x] = srcptrY[srcstrideY*(y+1) + srcdeltaY*x];

                        dstptrU[dststrideC*dstYC + dstdeltaC*dstXC] =
                            (uint8_t)((srcptrU[srcstrideC*srcYC + srcdeltaC*srcXC] +
                                       srcptrU[srcstrideC*(srcYC+1) + srcdeltaC*srcXC]) >> 1);

                        dstptrV[dststrideC*dstYC + dstdeltaC*dstXC] =
                            (uint8_t)((srcptrV[srcstrideC*srcYC + srcdeltaC*srcXC] +
                                       srcptrV[srcstrideC*(srcYC+1) + srcdeltaC*srcXC]) >> 1);
                    }
                }
            }
        }
    }
}


static int cmp_color_images(CT_Image img0, CT_Image img1, int ythresh, int cthresh)
{
    uint32_t x, y, width, height, stride0, stride1;
    int format0 = img0->format;
    int format1 = img1->format;
    uint8_t *ptrY0=0, *ptrU0=0, *ptrV0=0;
    uint8_t *ptrY1=0, *ptrU1=0, *ptrV1=0;
    uint32_t strideY0=0, deltaY0=1, strideC0=0, deltaC0=1;
    uint32_t strideY1=0, deltaY1=1, strideC1=0, deltaC1=1;
    uint32_t shiftX0 = 1, shiftY0 = 1;
    uint32_t shiftX1 = 1, shiftY1 = 1;
    int YUV0, YUV1;
    int code0=0, code1=0;

    ASSERT_(return -1, img0 && img1);
    ASSERT_(return -1, img0->width > 0 && img0->height > 0 &&
           img0->width == img1->width && img0->height == img1->height &&
           format0 == format1);

    width = img0->width;
    height = img0->height;
    stride0 = ct_stride_bytes(img0);
    stride1 = ct_stride_bytes(img1);

    YUV0 = get_yuv_params(img0, &ptrY0, &ptrU0, &ptrV0, &strideY0,
                            &deltaY0, &strideC0, &deltaC0,
                            &shiftX0, &shiftY0, &code0);
    YUV1 = get_yuv_params(img1, &ptrY1, &ptrU1, &ptrV1, &strideY1,
                          &deltaY1, &strideC1, &deltaC1,
                          &shiftX1, &shiftY1, &code1);

    if( format0 == VX_DF_IMAGE_RGB || format0 == VX_DF_IMAGE_RGBX )
    {
        int cn = ct_channels(format0);
        for( y = 0; y < height; y++ )
        {
            const uint8_t* ptr0 = (const uint8_t*)(img0->data.y + y*stride0);
            const uint8_t* ptr1 = (const uint8_t*)(img1->data.y + y*stride1);
            for( x = 0; x < width*cn; x++ )
            {
                if( abs(ptr0[x] - ptr1[x]) > ythresh )
                {
                    printf("images are very different at (%d, %d): %d vs %d\n", x, y, ptr0[x], ptr1[x]);
                    return -1;
                }
            }
        }
    }
    else
    {
        ASSERT_(return -1, YUV0 != 0 && YUV1 != 0 && code0 == code1);
        for( y = 0; y < height; y++ )
        {
            const uint8_t* tempptrY0 = (const uint8_t*)(ptrY0 + y*strideY0);
            const uint8_t* tempptrY1 = (const uint8_t*)(ptrY1 + y*strideY1);
            const uint8_t* tempptrU0_row = (const uint8_t*)(ptrU0 + (y>>shiftY0)*strideC0);
            const uint8_t* tempptrU1_row = (const uint8_t*)(ptrU1 + (y>>shiftY1)*strideC1);
            const uint8_t* tempptrV0_row = (const uint8_t*)(ptrV0 + (y>>shiftY0)*strideC0);
            const uint8_t* tempptrV1_row = (const uint8_t*)(ptrV1 + (y>>shiftY1)*strideC1);
            for( x = 0; x < width; x++, tempptrY0 += deltaY0, tempptrY1 += deltaY1 )
            {
                const uint8_t* tempptrU0 = tempptrU0_row + (x >> shiftX0)*deltaC0;
                const uint8_t* tempptrU1 = tempptrU1_row + (x >> shiftX1)*deltaC1;
                const uint8_t* tempptrV0 = tempptrV0_row + (x >> shiftX0)*deltaC0;
                const uint8_t* tempptrV1 = tempptrV1_row + (x >> shiftX1)*deltaC1;

                if( abs(tempptrY0[0] - tempptrY1[0]) > ythresh ||
                    abs(tempptrU0[0] - tempptrU1[0]) > cthresh ||
                    abs(tempptrV0[0] - tempptrV1[0]) > cthresh )
                {
                    printf("images are very different at (%d, %d): (%d, %d, %d) vs (%d, %d, %d)\n",
                           x, y, tempptrY0[0], tempptrU0[0], tempptrV0[0], tempptrY1[0], tempptrU1[0], tempptrV1[0]);
                    return -1;
                }
            }
        }
    }
    return 0;
}

TESTCASE(ColorConvert, CT_VXContext, ct_setup_vx_context, 0)

typedef struct {
    const char* name;
    vx_df_image srcformat;
    vx_df_image dstformat;
    int mode;
    int ythresh;
    int cthresh;
} format_arg;

#if 0
static void ct_print_image(CT_Image img, const char* name)
{
    uint32_t p, x, y, nplanes=1, width[3] = {img->width, 0, 0}, height[3] = {img->height, 0, 0};
    uint32_t stride[3] = {ct_stride_bytes(img), 0, 0};
    const uint8_t* ptr = img->data.y;
    int format = img->format;

    if( format == VX_DF_IMAGE_RGB || format == VX_DF_IMAGE_RGBX || format == VX_DF_IMAGE_UYVY || format == VX_DF_IMAGE_YUYV )
        width[0] *= format == VX_DF_IMAGE_RGB ? 3 : 4;
    else if( format == VX_DF_IMAGE_YUV4 || format == VX_DF_IMAGE_IYUV )
    {
        int scale = format == VX_DF_IMAGE_YUV4 ? 1 : 2;
        nplanes = 3;
        width[1] = width[2] = width[0]/scale;
        height[1] = height[2] = height[0]/scale;
        stride[1] = stride[2] = stride[0]/scale;
    }
    else if( format == VX_DF_IMAGE_NV12 || format == VX_DF_IMAGE_NV21 )
    {
        nplanes = 2;
        width[1] = width[0];
        height[1] = height[0]/2;
        stride[1] = stride[0];
    }

    printf("=========== %s =======\n", name);

    for( p = 0; p < nplanes; p++ )
    {
        for( y = 0; y < height[p]; y++, ptr += stride[p] )
        {
            for( x = 0; x < width[p]; x++ )
            {
                printf("%4d", ptr[x]);
            }
            printf("\n");
        }
        printf("\n");
    }
    printf("---------------------------\n");
}
#endif

#define CVT_CASE_(imm, from, to, ythresh, cthresh) \
    {#imm "/" #from "=>" #to, VX_DF_IMAGE_##from, VX_DF_IMAGE_##to, CT_##imm##_MODE, ythresh, cthresh}

#define CVT_CASE(from, to, ythresh, cthresh) \
    CVT_CASE_(Immediate, from, to, ythresh, cthresh), \
    CVT_CASE_(Graph, from, to, ythresh, cthresh)

TEST_WITH_ARG(ColorConvert, testOnRandomAndNatural, format_arg,
              CVT_CASE(RGB, RGBX, 0, 0),
              CVT_CASE(RGB, NV12, 1, 1),
              CVT_CASE(RGB, IYUV, 1, 1),
              CVT_CASE(RGB, YUV4, 1, 1),

              CVT_CASE(RGBX, RGB, 0, 0),
              CVT_CASE(RGBX, NV12, 1, 1),
              CVT_CASE(RGBX, IYUV, 1, 1),
              CVT_CASE(RGBX, YUV4, 1, 1),

              CVT_CASE(NV12, RGB, 1, 1),
              CVT_CASE(NV12, RGBX, 1, 1),
//              CVT_CASE(NV12, NV21, 0, 0),
              CVT_CASE(NV12, IYUV, 0, 0),
              CVT_CASE(NV12, YUV4, 0, 0),

              CVT_CASE(NV21, RGB, 1, 1),
              CVT_CASE(NV21, RGBX, 1, 1),
//              CVT_CASE(NV21, NV12, 0, 0),
              CVT_CASE(NV21, IYUV, 0, 0),
              CVT_CASE(NV21, YUV4, 0, 0),

              CVT_CASE(UYVY, RGB, 1, 1),
              CVT_CASE(UYVY, RGBX, 1, 1),
              CVT_CASE(UYVY, NV12, 0, 0),
              CVT_CASE(UYVY, IYUV, 0, 0),
//              CVT_CASE(UYVY, YUV4, 0, 0),

              CVT_CASE(YUYV, RGB, 1, 1),
              CVT_CASE(YUYV, RGBX, 1, 1),
              CVT_CASE(YUYV, NV12, 0, 0),
              CVT_CASE(YUYV, IYUV, 0, 0),
//              CVT_CASE(YUYV, YUV4, 0, 0),

              CVT_CASE(IYUV, RGB, 1, 1),
              CVT_CASE(IYUV, RGBX, 1, 1),
              CVT_CASE(IYUV, NV12, 0, 0),
              CVT_CASE(IYUV, YUV4, 0, 0),
              )
{
    int srcformat = arg_->srcformat;
    int dstformat = arg_->dstformat;
    int ythresh = arg_->ythresh;
    int cthresh = arg_->cthresh;
    int mode = arg_->mode;
    vx_image src=0, dst=0;
    CT_Image src0, dst0, dst1;
    vx_graph graph = 0;
    vx_node node = 0;
    vx_context context = context_->vx_context_;
    int iter, niters = 50;
    uint64_t rng;

    rng = CT()->seed_;

    for( iter = 0; iter < niters; iter++ )
    {
        int width = ct_roundf(ct_log_rng(&rng, 0, 10));
        int height = ct_roundf(ct_log_rng(&rng, 0, 10));
        vx_enum space = VX_COLOR_SPACE_BT709;

        width = CT_MAX((width+1)&-2, 2);
        height = CT_MAX((height+1)&-2, 2);

        if( !ct_check_any_size() )
        {
            width = CT_MIN((width + 7) & -8, 640);
            height = CT_MIN((height + 7) & -8, 480);
        }

        if( srcformat == VX_DF_IMAGE_RGB || srcformat == VX_DF_IMAGE_RGBX )
        {
            int scn = srcformat == VX_DF_IMAGE_RGB ? 3 : 4;
            if( iter == 0 )
            {
                ASSERT_NO_FAILURE(src0 = ct_read_image("lena.bmp", scn));
                width = src0->width;
                height = src0->height;
            }
            else if( iter == 1 )
            {
                ASSERT_NO_FAILURE(src0 = ct_read_image("colors.bmp", scn));
                width = src0->width;
                height = src0->height;
            }
            else
            {
                ASSERT_NO_FAILURE(src0 = ct_allocate_ct_image_random(width, height, srcformat, &rng, 0, 256));
            }
        }
        else
        {
            ASSERT_NO_FAILURE(src0 = ct_allocate_ct_image_random(width, height, srcformat, &rng, 0, 256));
        }
        ASSERT_NO_FAILURE(src = ct_image_to_vx_image(src0, context));
        ASSERT_VX_OBJECT(src, VX_TYPE_IMAGE);
/* commented out until specification clarifies VX_IMAGE_RANGE
        ASSERT_NE_VX_STATUS(VX_SUCCESS, vxSetImageAttribute(src, VX_IMAGE_RANGE, &range, sizeof(range)));
*/
        ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetImageAttribute(src, VX_IMAGE_SPACE, &space, sizeof(space)));

        ASSERT_NO_FAILURE(dst0 = ct_allocate_image(width, height, dstformat));
        ASSERT_NO_FAILURE(reference_colorconvert(src0, dst0));
        ASSERT_VX_OBJECT(dst = vxCreateImage(context, width, height, dstformat), VX_TYPE_IMAGE);
        ASSERT_VX_OBJECT(dst, VX_TYPE_IMAGE);
/* commented out until specification clarifies VX_IMAGE_RANGE
        ASSERT_NE_VX_STATUS(VX_SUCCESS, vxSetImageAttribute(dst, VX_IMAGE_RANGE, &range, sizeof(range)));
*/
        ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetImageAttribute(dst, VX_IMAGE_SPACE, &space, sizeof(space)));

        if( mode == CT_Immediate_MODE )
        {
            ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxuColorConvert(context, src, dst));
        }
        else
        {
            ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
            ASSERT_VX_OBJECT(graph, VX_TYPE_GRAPH);
            ASSERT_VX_OBJECT(node = vxColorConvertNode(graph, src, dst), VX_TYPE_NODE);
            ASSERT_VX_OBJECT(node, VX_TYPE_NODE);
            VX_CALL(vxVerifyGraph(graph));
            VX_CALL(vxProcessGraph(graph));
        }
        dst1 = ct_image_from_vx_image(dst);

        ASSERT(cmp_color_images(dst0, dst1, ythresh, cthresh) >= 0);
        VX_CALL(vxReleaseImage(&src));
        VX_CALL(vxReleaseImage(&dst));

        if(node)
            VX_CALL(vxReleaseNode(&node));

        if(graph)
            VX_CALL(vxReleaseGraph(&graph));

        ASSERT(node == 0 && graph == 0);
        CT_CollectGarbage(CT_GC_IMAGE);
    }
}

TESTCASE_TESTS(ColorConvert, testOnRandomAndNatural)

#endif //OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION