morgan/FreeRDP
1
0
Fork 0
mirror of https://github.com/morgan9e/FreeRDP synced 2026-04-15 00:44:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

[primitives,yuv] improve unit test

Browse Source 
* add comparison tests between generic and SIMD optimized RGB <-> YUV
  routines
* fix inconsistencies due to chroma filter in RGB -> YUV444 -> RGB test
* enable primitives test on all platforms
This commit is contained in:
akallabeth
2025-01-05 21:53:18 +01:00
parent 691092306e
commit e93cd60352
2 changed files with 494 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libfreerdp/primitives/CMakeLists.txt
View File

@@ -91,6 +91,6 @@ endif()
freerdp_object_library_add(freerdp-primitives)
if(BUILD_TESTING_INTERNAL AND NOT WIN32 AND NOT APPLE)
if(BUILD_TESTING_INTERNAL)
add_subdirectory(test)
endif()

612
libfreerdp/primitives/test/TestPrimitivesYUV.c
View File

@@ -10,6 +10,8 @@
#include <freerdp/primitives.h>
#include <freerdp/utils/profiler.h>
#include "../prim_internal.h"
#define TAG __FILE__
#define PADDING_FILL_VALUE 0x37
@@ -33,7 +35,8 @@ static BOOL similar(const BYTE* src, const BYTE* dst, size_t size)
return TRUE;
}
static BOOL similarRGB(const BYTE* src, const BYTE* dst, size_t size, UINT32 format, BOOL use444)
static BOOL similarRGB(size_t y, const BYTE* src, const BYTE* dst, size_t size, UINT32 format,
BOOL use444)
{
const UINT32 bpp = FreeRDPGetBytesPerPixel(format);
BYTE fill = PADDING_FILL_VALUE;
@@ -60,13 +63,32 @@ static BOOL similarRGB(const BYTE* src, const BYTE* dst, size_t size, UINT32 for
FreeRDPSplitColor(sColor, format, &sR, &sG, &sB, &sA, NULL);
FreeRDPSplitColor(dColor, format, &dR, &dG, &dB, &dA, NULL);
if ((labs(sR - dR) > maxDiff) || (labs(sG - dG) > maxDiff) || (labs(sB - dB) > maxDiff))
const long diffr = labs(1L * sR - dR);
const long diffg = labs(1L * sG - dG);
const long diffb = labs(1L * sB - dB);
if ((diffr > maxDiff) || (diffg > maxDiff) || (diffb > maxDiff))
{
(void)fprintf(
stderr,
"Color value mismatch R[%02X %02X], G[%02X %02X], B[%02X %02X] at position %" PRIuz
"\n",
sR, dR, sG, dG, sA, dA, x);
/* AVC444 uses an averaging filter for luma pixel U/V and reverses it in YUV444 -> RGB
* this is lossy and does not handle all combinations well so the 2x,2y pixel can be
* quite different after RGB -> YUV444 -> RGB conversion.
*
* skip these pixels to avoid failing the test
*/
if (use444 && ((x % 2) == 0) && ((y % 2) == 0))
{
continue;
}
const BYTE sY = RGB2Y(sR, sG, sB);
const BYTE sU = RGB2U(sR, sG, sB);
const BYTE sV = RGB2V(sR, sG, sB);
const BYTE dY = RGB2Y(dR, dG, dB);
const BYTE dU = RGB2U(dR, dG, dB);
const BYTE dV = RGB2V(dR, dG, dB);
(void)fprintf(stderr,
"[%s] Color value mismatch R[%02X %02X], G[%02X %02X], B[%02X %02X] at "
"position %" PRIuz "\n",
use444 ? "AVC444" : "AVC420", sR, dR, sG, dG, sA, dA, x);
return FALSE;
}
@@ -371,6 +393,7 @@ static BOOL TestPrimitiveYUVCombine(primitives_t* prims, prim_size_t roi)
PROFILER_PRINT_FOOTER
rc = TRUE;
fail:
printf("[%s] run %s.\n", __func__, (rc) ? "SUCCESS" : "FAILED");
PROFILER_FREE(yuvCombine)
PROFILER_FREE(yuvSplit)
@@ -457,14 +480,7 @@ static BOOL TestPrimitiveYUV(primitives_t* prims, prim_size_t roi, BOOL use444)
for (size_t y = 0; y < roi.height; y++)
{
BYTE* line = &rgb[y * stride];
for (UINT32 x = 0; x < roi.width; x++)
{
line[x * 4 + 0] = 0x81;
line[x * 4 + 1] = 0x33;
line[x * 4 + 2] = 0xAB;
line[x * 4 + 3] = 0xFF;
}
winpr_RAND(line, stride);
}
yuv_step[0] = awidth;
@@ -568,14 +584,16 @@ static BOOL TestPrimitiveYUV(primitives_t* prims, prim_size_t roi, BOOL use444)
(!check_padding(yuv[2], uvsize, padding, "V")))
goto fail;
#if 0 // TODO: lossy conversion, we have a lot of outliers that prevent the check to pass
for (size_t y = 0; y < roi.height; y++)
{
BYTE* srgb = &rgb[y * stride];
BYTE* drgb = &rgb_dst[y * stride];
if (!similarRGB(srgb, drgb, roi.width, DstFormat, use444))
if (!similarRGB(y, srgb, drgb, roi.width, DstFormat, use444))
goto fail;
}
#endif
PROFILER_FREE(rgbToYUV420)
PROFILER_FREE(rgbToYUV444)
@@ -585,6 +603,7 @@ static BOOL TestPrimitiveYUV(primitives_t* prims, prim_size_t roi, BOOL use444)
res = TRUE;
fail:
printf("[%s] run %s.\n", __func__, (res) ? "SUCCESS" : "FAILED");
free_padding(rgb, padding);
free_padding(rgb_dst, padding);
free_padding(yuv[0], padding);
@@ -628,6 +647,7 @@ static void free_yuv420(BYTE** planes, UINT32 padding)
planes[1] = NULL;
planes[2] = NULL;
}
static BOOL check_yuv420(BYTE** planes, UINT32 width, UINT32 height, UINT32 padding)
{
const size_t size = 1ULL * width * height;
@@ -778,27 +798,14 @@ static BOOL TestPrimitiveRgbToLumaChroma(primitives_t* prims, prim_size_t roi, U
{
BYTE* line = &rgb[y * stride];
for (UINT32 x = 0; x < roi.width; x++)
{
#if 1
line[x * 4 + 0] = prand(UINT8_MAX);
line[x * 4 + 1] = prand(UINT8_MAX);
line[x * 4 + 2] = prand(UINT8_MAX);
line[x * 4 + 3] = prand(UINT8_MAX);
#else
line[x * 4 + 0] = (y * roi.width + x) * 16 + 5;
line[x * 4 + 1] = (y * roi.width + x) * 16 + 7;
line[x * 4 + 2] = (y * roi.width + x) * 16 + 11;
line[x * 4 + 3] = (y * roi.width + x) * 16 + 0;
#endif
}
winpr_RAND(line, 4ULL * roi.width);
}
yuv_step[0] = awidth;
yuv_step[1] = uvwidth;
yuv_step[2] = uvwidth;
for (UINT32 x = 0; x < sizeof(formats) / sizeof(formats[0]); x++)
for (UINT32 x = 0; x < ARRAYSIZE(formats); x++)
{
pstatus_t rc = -1;
const UINT32 DstFormat = formats[x];
@@ -877,6 +884,7 @@ static BOOL TestPrimitiveRgbToLumaChroma(primitives_t* prims, prim_size_t roi, U
res = TRUE;
fail:
printf("[%s] run %s.\n", __func__, (res) ? "SUCCESS" : "FAILED");
free_padding(rgb, padding);
free_yuv420(luma, padding);
free_yuv420(chroma, padding);
@@ -885,108 +893,474 @@ fail:
return res;
}
static BOOL run_tests(prim_size_t roi)
{
BOOL rc = FALSE;
for (UINT32 type = PRIMITIVES_PURE_SOFT; type <= PRIMITIVES_AUTODETECT; type++)
{
primitives_t* prims = primitives_get_by_type(type);
if (!prims)
{
printf("primitives type %d not supported\n", type);
continue;
}
for (UINT32 x = 0; x < 5; x++)
{
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveYUV(prims, roi, TRUE))
goto fail;
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveYUV(prims, roi, FALSE))
goto fail;
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveYUVCombine(prims, roi))
goto fail;
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveRgbToLumaChroma(prims, roi, 1))
goto fail;
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveRgbToLumaChroma(prims, roi, 2))
goto fail;
printf("---------------------- END --------------------------\n");
}
}
rc = TRUE;
fail:
printf("[%s] run %s.\n", __func__, (rc) ? "SUCCESS" : "FAILED");
return rc;
}
static void free_yuv(BYTE* yuv[3])
{
for (size_t x = 0; x < 3; x++)
{
free(yuv[x]);
yuv[x] = NULL;
}
}
static BOOL allocate_yuv(BYTE* yuv[3], prim_size_t roi)
{
yuv[0] = calloc(roi.width, roi.height);
yuv[1] = calloc(roi.width, roi.height);
yuv[2] = calloc(roi.width, roi.height);
if (!yuv[0] || !yuv[1] || !yuv[2])
{
free_yuv(yuv);
return FALSE;
}
winpr_RAND(yuv[0], 1ULL * roi.width * roi.height);
winpr_RAND(yuv[1], 1ULL * roi.width * roi.height);
winpr_RAND(yuv[2], 1ULL * roi.width * roi.height);
return TRUE;
}
static BOOL yuv444_to_rgb(BYTE* rgb, size_t stride, const BYTE* yuv[3], const UINT32 yuvStep[3],
prim_size_t roi)
{
for (size_t y = 0; y < roi.height; y++)
{
const BYTE* yline[3] = {
yuv[0] + y * roi.width,
yuv[1] + y * roi.width,
yuv[2] + y * roi.width,
};
BYTE* line = &rgb[y * stride];
for (size_t x = 0; x < roi.width; x++)
{
const BYTE Y = yline[0][x];
const BYTE U = yline[1][x];
const BYTE V = yline[2][x];
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
writePixelBGRX(&line[x * 4], 4, PIXEL_FORMAT_BGRX32, r, g, b, 0xFF);
}
}
}
/* Check the result of generic matches the optimized routine.
*
*/
static BOOL compare_yuv444_to_rgb(prim_size_t roi, DWORD type)
{
BOOL rc = FALSE;
const UINT32 format = PIXEL_FORMAT_BGRA32;
BYTE* yuv[3] = { 0 };
const UINT32 yuvStep[3] = { roi.width, roi.width, roi.width };
const size_t stride = 4ULL * roi.width;
primitives_t* prims = primitives_get_by_type(type);
if (!prims)
{
printf("primitives type %" PRIu32 " not supported, skipping\n", type);
return TRUE;
}
BYTE* rgb1 = calloc(roi.height, stride);
BYTE* rgb2 = calloc(roi.height, stride);
primitives_t* soft = primitives_get_by_type(PRIMITIVES_PURE_SOFT);
if (!soft)
goto fail;
if (!allocate_yuv(yuv, roi) || !rgb1 || !rgb2)
goto fail;
if (soft->YUV444ToRGB_8u_P3AC4R(yuv, yuvStep, rgb1, stride, format, &roi) != PRIMITIVES_SUCCESS)
goto fail;
if (prims->YUV444ToRGB_8u_P3AC4R(yuv, yuvStep, rgb2, stride, format, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
for (size_t y = 0; y < roi.height; y++)
{
const BYTE* yline[3] = {
yuv[0] + y * roi.width,
yuv[1] + y * roi.width,
yuv[2] + y * roi.width,
};
const BYTE* line1 = &rgb1[y * stride];
const BYTE* line2 = &rgb2[y * stride];
for (size_t x = 0; x < roi.width; x++)
{
const int Y = yline[0][x];
const int U = yline[1][x];
const int V = yline[2][x];
const UINT32 color1 = FreeRDPReadColor(&line1[x * 4], format);
const UINT32 color2 = FreeRDPReadColor(&line2[x * 4], format);
BYTE r1, g1, b1;
FreeRDPSplitColor(color1, format, &r1, &g1, &b1, NULL, NULL);
BYTE r2, g2, b2;
FreeRDPSplitColor(color2, format, &r2, &g2, &b2, NULL, NULL);
const int dr12 = abs(r1 - r2);
const int dg12 = abs(g1 - g2);
const int db12 = abs(b1 - b2);
if ((dr12 != 0) || (dg12 != 0) || (db12 != 0))
{
printf("{\n");
printf("\tdiff 1/2: yuv {%d, %d, %d}, rgb {%d, %d, %d}\n", Y, U, V, dr12, dg12,
db12);
printf("}\n");
}
if ((dr12 > 0) || (dg12 > 0) || (db12 > 0))
{
fprintf(stderr,
"[%" PRIuz "x%" PRIuz "] generic and optimized data mismatch: r[0x%" PRIx8
"|0x%" PRIx8 "] g[0x%" PRIx8 "|0x%" PRIx8 "] b[0x%" PRIx8 "|0x%" PRIx8
"]\n",
x, y, r1, r2, g1, g2, b1, b2);
goto fail;
}
}
}
rc = TRUE;
fail:
printf("%s finished with %s\n", __func__, rc ? "SUCCESS" : "FAILURE");
free_yuv(yuv);
free(rgb1);
free(rgb2);
return rc;
}
/* Check the result of generic matches the optimized routine.
*
*/
static BOOL compare_rgb_to_yuv444(prim_size_t roi, DWORD type)
{
BOOL rc = FALSE;
const UINT32 format = PIXEL_FORMAT_BGRA32;
const size_t stride = 4ULL * roi.width;
const UINT32 yuvStep[] = { roi.width, roi.width, roi.width };
BYTE* yuv1[3] = { 0 };
BYTE* yuv2[3] = { 0 };
primitives_t* prims = primitives_get_by_type(type);
if (!prims)
{
printf("primitives type %" PRIu32 " not supported, skipping\n", type);
return TRUE;
}
BYTE* rgb = calloc(roi.height, stride);
primitives_t* soft = primitives_get_by_type(PRIMITIVES_PURE_SOFT);
if (!soft || !rgb)
goto fail;
if (!allocate_yuv(yuv1, roi) || !allocate_yuv(yuv2, roi))
goto fail;
if (soft->RGBToYUV444_8u_P3AC4R(rgb, format, stride, yuv1, yuvStep, &roi) != PRIMITIVES_SUCCESS)
goto fail;
if (prims->RGBToYUV444_8u_P3AC4R(rgb, format, stride, yuv2, yuvStep, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
for (size_t y = 0; y < roi.height; y++)
{
const BYTE* yline1[3] = {
yuv1[0] + y * roi.width,
yuv1[1] + y * roi.width,
yuv1[2] + y * roi.width,
};
const BYTE* yline2[3] = {
yuv2[0] + y * roi.width,
yuv2[1] + y * roi.width,
yuv2[2] + y * roi.width,
};
for (size_t x = 0; x < ARRAYSIZE(yline1); x++)
{
if (memcmp(yline1[x], yline2[x], yuvStep[x]) != 0)
{
fprintf(stderr, "[%s] compare failed in line %" PRIuz, __func__, x);
goto fail;
}
}
}
rc = TRUE;
fail:
printf("%s finished with %s\n", __func__, rc ? "SUCCESS" : "FAILURE");
free(rgb);
free_yuv(yuv1);
free_yuv(yuv2);
return rc;
}
/* Check the result of generic matches the optimized routine.
*
*/
static BOOL compare_yuv420_to_rgb(prim_size_t roi, DWORD type)
{
BOOL rc = FALSE;
const UINT32 format = PIXEL_FORMAT_BGRA32;
BYTE* yuv[3] = { 0 };
const UINT32 yuvStep[3] = { roi.width, roi.width / 2, roi.width / 2 };
const size_t stride = 4ULL * roi.width;
primitives_t* prims = primitives_get_by_type(type);
if (!prims)
{
printf("primitives type %" PRIu32 " not supported, skipping\n", type);
return TRUE;
}
BYTE* rgb1 = calloc(roi.height, stride);
BYTE* rgb2 = calloc(roi.height, stride);
primitives_t* soft = primitives_get_by_type(PRIMITIVES_PURE_SOFT);
if (!soft)
goto fail;
if (!allocate_yuv(yuv, roi) || !rgb1 || !rgb2)
goto fail;
if (soft->YUV420ToRGB_8u_P3AC4R(yuv, yuvStep, rgb1, stride, format, &roi) != PRIMITIVES_SUCCESS)
goto fail;
if (prims->YUV420ToRGB_8u_P3AC4R(yuv, yuvStep, rgb2, stride, format, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
for (size_t y = 0; y < roi.height; y++)
{
const BYTE* yline[3] = {
yuv[0] + y * yuvStep[0],
yuv[1] + y * yuvStep[1],
yuv[2] + y * yuvStep[2],
};
const BYTE* line1 = &rgb1[y * stride];
const BYTE* line2 = &rgb2[y * stride];
for (size_t x = 0; x < roi.width; x++)
{
const int Y = yline[0][x];
const int U = yline[1][x / 2];
const int V = yline[2][x / 2];
const UINT32 color1 = FreeRDPReadColor(&line1[x * 4], format);
const UINT32 color2 = FreeRDPReadColor(&line2[x * 4], format);
BYTE r1, g1, b1;
FreeRDPSplitColor(color1, format, &r1, &g1, &b1, NULL, NULL);
BYTE r2, g2, b2;
FreeRDPSplitColor(color2, format, &r2, &g2, &b2, NULL, NULL);
const int dr12 = abs(r1 - r2);
const int dg12 = abs(g1 - g2);
const int db12 = abs(b1 - b2);
if ((dr12 != 0) || (dg12 != 0) || (db12 != 0))
{
printf("{\n");
printf("\tdiff 1/2: yuv {%d, %d, %d}, rgb {%d, %d, %d}\n", Y, U, V, dr12, dg12,
db12);
printf("}\n");
}
if ((dr12 > 0) || (dg12 > 0) || (db12 > 0))
{
printf("[%s] failed: r[%" PRIx8 "|%" PRIx8 "] g[%" PRIx8 "|%" PRIx8 "] b[%" PRIx8
"|%" PRIx8 "]\n",
__func__, r1, r2, g1, g2, b1, b2);
goto fail;
}
}
}
rc = TRUE;
fail:
printf("%s finished with %s\n", __func__, rc ? "SUCCESS" : "FAILURE");
free_yuv(yuv);
free(rgb1);
free(rgb2);
return rc;
}
/* Check the result of generic matches the optimized routine.
*
*/
static BOOL compare_rgb_to_yuv420(prim_size_t roi, DWORD type)
{
BOOL rc = FALSE;
const UINT32 format = PIXEL_FORMAT_BGRA32;
const size_t stride = 4ULL * roi.width;
const UINT32 yuvStep[] = { roi.width, roi.width / 2, roi.width / 2 };
BYTE* yuv1[3] = { 0 };
BYTE* yuv2[3] = { 0 };
primitives_t* prims = primitives_get_by_type(type);
if (!prims)
{
printf("primitives type %" PRIu32 " not supported, skipping\n", type);
return TRUE;
}
BYTE* rgb = calloc(roi.height, stride);
BYTE* rgbcopy = calloc(roi.height, stride);
primitives_t* soft = primitives_get_by_type(PRIMITIVES_PURE_SOFT);
if (!soft || !rgb || !rgbcopy)
goto fail;
winpr_RAND(rgb, roi.height * stride);
memcpy(rgbcopy, rgb, roi.height * stride);
if (!allocate_yuv(yuv1, roi) || !allocate_yuv(yuv2, roi))
goto fail;
if (soft->RGBToYUV420_8u_P3AC4R(rgb, format, stride, yuv1, yuvStep, &roi) != PRIMITIVES_SUCCESS)
goto fail;
if (memcmp(rgb, rgbcopy, roi.height * stride) != 0)
goto fail;
if (prims->RGBToYUV420_8u_P3AC4R(rgb, format, stride, yuv2, yuvStep, &roi) !=
PRIMITIVES_SUCCESS)
goto fail;
for (size_t y = 0; y < roi.height; y++)
{
const BYTE* yline1[3] = {
&yuv1[0][y * yuvStep[0]],
&yuv1[1][(y / 2) * yuvStep[1]],
&yuv1[2][(y / 2) * yuvStep[2]],
};
const BYTE* yline2[3] = {
&yuv2[0][y * yuvStep[0]],
&yuv2[1][(y / 2) * yuvStep[1]],
&yuv2[2][(y / 2) * yuvStep[2]],
};
for (size_t x = 0; x < ARRAYSIZE(yline1); x++)
{
if (memcmp(yline1[x], yline2[x], yuvStep[x]) != 0)
{
fprintf(stderr, "[%s] compare failed in line %" PRIuz, __func__, x);
goto fail;
}
}
}
rc = TRUE;
fail:
printf("%s finished with %s\n", __func__, rc ? "SUCCESS" : "FAILURE");
free(rgb);
free(rgbcopy);
free_yuv(yuv1);
free_yuv(yuv2);
return rc;
}
int TestPrimitivesYUV(int argc, char* argv[])
{
BOOL large = (argc > 1);
int rc = -1;
WINPR_UNUSED(argc);
WINPR_UNUSED(argv);
prim_test_setup(FALSE);
primitives_t* prims = primitives_get();
prim_size_t roi = { 0 };
for (UINT32 x = 0; x < 5; x++)
if (argc > 1)
{
prim_size_t roi = { 0 };
// NOLINTNEXTLINE(cert-err34-c)
int crc = sscanf(argv[1], "%" PRIu32 "x%" PRIu32, &roi.width, &roi.height);
if (argc > 1)
if (crc != 2)
{
// NOLINTNEXTLINE(cert-err34-c)
int crc = sscanf(argv[1], "%" PRIu32 "x%" PRIu32, &roi.width, &roi.height);
if (crc != 2)
{
roi.width = 1920;
roi.height = 1080;
}
roi.width = 1920;
roi.height = 1080;
}
else
get_size(large, &roi.width, &roi.height);
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveYUV(generic, roi, TRUE))
{
printf("TestPrimitiveYUV (444) failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("------------------- OPTIMIZED -----------------------\n");
if (!TestPrimitiveYUV(prims, roi, TRUE))
{
printf("TestPrimitiveYUV (444) failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveYUV(generic, roi, FALSE))
{
printf("TestPrimitiveYUV (420) failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("------------------- OPTIMIZED -----------------------\n");
if (!TestPrimitiveYUV(prims, roi, FALSE))
{
printf("TestPrimitiveYUV (420) failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveYUVCombine(generic, roi))
{
printf("TestPrimitiveYUVCombine failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("------------------- OPTIMIZED -----------------------\n");
if (!TestPrimitiveYUVCombine(prims, roi))
{
printf("TestPrimitiveYUVCombine failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("------------------- OPTIMIZED -----------------------\n");
if (!TestPrimitiveRgbToLumaChroma(prims, roi, 1))
{
printf("TestPrimitiveRgbToLumaChroma failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
printf("-------------------- GENERIC ------------------------\n");
if (!TestPrimitiveRgbToLumaChroma(prims, roi, 2))
{
printf("TestPrimitiveYUVCombine failed.\n");
goto end;
}
printf("---------------------- END --------------------------\n");
}
else
get_size(large, &roi.width, &roi.height);
prim_test_setup(FALSE);
for (UINT32 type = PRIMITIVES_PURE_SOFT; type <= PRIMITIVES_AUTODETECT; type++)
{
if (!compare_yuv444_to_rgb(roi, type))
goto end;
if (!compare_rgb_to_yuv444(roi, type))
goto end;
if (!compare_yuv420_to_rgb(roi, type))
goto end;
if (!compare_rgb_to_yuv420(roi, type))
goto end;
}
if (!run_tests(roi))
goto end;
rc = 0;
end:
printf("[%s] finished, status %s [%d]\n", __func__, (rc == 0) ? "SUCCESS" : "FAILURE", rc);
return rc;
}