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

Merge pull request #11045 from akallabeth/yuv-filter-fix

Browse Source 
Yuv filter fix
This commit is contained in:
akallabeth
2025-01-10 19:19:34 +01:00
committed by GitHub
parent 1544f827c3 4a7de1360a
commit 140d9472aa
16 changed files with 2300 additions and 1154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cmake/ConfigOptions.cmake
View File

@@ -54,6 +54,7 @@ if(WIN32 AND NOT UWP)
option(WITH_WIN8 "Use Windows 8 libraries" OFF)
endif()
option(BUILD_BENCHMARK "Build benchmark tools (for debugging and development only)" OFF)
option(BUILD_TESTING "Build unit tests (compatible with packaging)" OFF)
cmake_dependent_option(
BUILD_TESTING_INTERNAL "Build unit tests (CI only, not for packaging!)" OFF "NOT BUILD_TESTING" OFF

24
include/freerdp/primitives.h
View File

@@ -182,7 +182,7 @@ typedef pstatus_t (*__RGBToYUV420_8u_P3AC4R_t)(const BYTE* WINPR_RESTRICT pSrc,
const prim_size_t* WINPR_RESTRICT roi);
typedef pstatus_t (*__RGBToYUV444_8u_P3AC4R_t)(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
UINT32 dstStep[3],
const UINT32 dstStep[3],
const prim_size_t* WINPR_RESTRICT roi);
typedef pstatus_t (*__YUV420CombineToYUV444_t)(avc444_frame_type type,
const BYTE* WINPR_RESTRICT pSrc[3],
@@ -274,6 +274,28 @@ typedef enum
FREERDP_API BOOL primitives_init(primitives_t* p, primitive_hints hints);
FREERDP_API void primitives_uninit(void);
/** @brief get a specific primitives implementation
*
* This will try to return the primitives implementation suggested by \b hint
* If that does not exist or does not work on the platform any other (e.g. usually pure
* software) is returned
*
* @param hint the type of primitives to return.
* @return A primitive implementation matching the hint closest or \b NULL in case of failure.
* @since version 3.11.0
*/
FREERDP_API primitives_t* primitives_get_by_type(primitive_hints type);
FREERDP_API const char* primitives_avc444_frame_type_str(avc444_frame_type type);
/** @brief convert a hint to a string
*
* @param hint the hint to stringify
* @return the string representation of the hint
* @since version 3.11.0
*/
FREERDP_API const char* primtives_hint_str(primitive_hints hint);
#ifdef __cplusplus
}
#endif

10
libfreerdp/primitives/CMakeLists.txt
View File

@@ -29,9 +29,9 @@ set(PRIMITIVES_SSE2_SRCS sse/prim_colors_sse2.c sse/prim_set_sse2.c)
set(PRIMITIVES_SSE3_SRCS sse/prim_add_sse3.c sse/prim_alphaComp_sse3.c sse/prim_andor_sse3.c sse/prim_shift_sse3.c)
set(PRIMITIVES_SSSE3_SRCS sse/prim_YUV_ssse3.c sse/prim_sign_ssse3.c sse/prim_YCoCg_ssse3.c)
set(PRIMITIVES_SSSE3_SRCS sse/prim_sign_ssse3.c sse/prim_YCoCg_ssse3.c)
set(PRIMITIVES_SSE4_1_SRCS sse/prim_copy_sse4_1.c)
set(PRIMITIVES_SSE4_1_SRCS sse/prim_copy_sse4_1.c sse/prim_YUV_sse4.1.c)
set(PRIMITIVES_SSE4_2_SRCS)
@@ -91,6 +91,10 @@ endif()
freerdp_object_library_add(freerdp-primitives)
if(BUILD_TESTING_INTERNAL AND NOT WIN32 AND NOT APPLE)
if(BUILD_BENCHMARK)
add_subdirectory(benchmark)
endif()
if(BUILD_TESTING_INTERNAL)
add_subdirectory(test)
endif()

20
libfreerdp/primitives/benchmark/CMakeLists.txt Normal file
View File

@@ -0,0 +1,20 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright 2025 Armin Novak <anovak@thincast.com>
# Copyright 2025 Thincast Technologies GmbH
#
# 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.
add_executable(primitives-benchmark benchmark.c)
target_link_libraries(primitives-benchmark PRIVATE winpr freerdp)

252
libfreerdp/primitives/benchmark/benchmark.c Normal file
View File

@@ -0,0 +1,252 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* primitives benchmarking tool
*
* Copyright 2025 Armin Novak <anovak@thincast.com>
* Copyright 2025 Thincast Technologies GmbH
*
* 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 <stdio.h>
#include <winpr/crypto.h>
#include <winpr/sysinfo.h>
#include <freerdp/primitives.h>
typedef struct
{
BYTE* channels[3];
UINT32 steps[3];
prim_size_t roi;
BYTE* outputBuffer;
BYTE* outputChannels[3];
BYTE* rgbBuffer;
UINT32 outputStride;
UINT32 testedFormat;
} primitives_YUV_benchmark;
static void primitives_YUV_benchmark_free(primitives_YUV_benchmark* bench)
{
if (!bench)
return;
free(bench->outputBuffer);
free(bench->rgbBuffer);
for (size_t i = 0; i < 3; i++)
{
free(bench->outputChannels[i]);
free(bench->channels[i]);
}
const primitives_YUV_benchmark empty = { 0 };
*bench = empty;
}
static primitives_YUV_benchmark primitives_YUV_benchmark_init(void)
{
primitives_YUV_benchmark ret = { 0 };
ret.roi.width = 3840 * 4;
ret.roi.height = 2160 * 4;
ret.outputStride = ret.roi.width * 4;
ret.testedFormat = PIXEL_FORMAT_BGRA32;
ret.outputBuffer = calloc(ret.outputStride, ret.roi.height);
if (!ret.outputBuffer)
goto fail;
ret.rgbBuffer = calloc(ret.outputStride, ret.roi.height);
if (!ret.rgbBuffer)
goto fail;
winpr_RAND(ret.rgbBuffer, 1ULL * ret.outputStride * ret.roi.height);
for (size_t i = 0; i < 3; i++)
{
ret.channels[i] = calloc(ret.roi.width, ret.roi.height);
ret.outputChannels[i] = calloc(ret.roi.width, ret.roi.height);
if (!ret.channels[i] || !ret.outputChannels[i])
goto fail;
winpr_RAND(ret.channels[i], 1ull * ret.roi.width * ret.roi.height);
ret.steps[i] = ret.roi.width;
}
return ret;
fail:
primitives_YUV_benchmark_free(&ret);
return ret;
}
static const char* print_time(UINT64 t, char* buffer, size_t size)
{
(void)_snprintf(buffer, size, "%u.%03u.%03u.%03u", (unsigned)(t / 1000000000ull),
(unsigned)((t / 1000000ull) % 1000), (unsigned)((t / 1000ull) % 1000),
(unsigned)((t) % 1000));
return buffer;
}
static BOOL primitives_YUV420_benchmark_run(primitives_YUV_benchmark* bench, primitives_t* prims)
{
const BYTE* channels[3] = { 0 };
for (size_t i = 0; i < 3; i++)
channels[i] = bench->channels[i];
for (size_t x = 0; x < 10; x++)
{
const UINT64 start = winpr_GetTickCount64NS();
pstatus_t status =
prims->YUV420ToRGB_8u_P3AC4R(channels, bench->steps, bench->outputBuffer,
bench->outputStride, bench->testedFormat, &bench->roi);
const UINT64 end = winpr_GetTickCount64NS();
if (status != PRIMITIVES_SUCCESS)
{
(void)fprintf(stderr, "Running YUV420ToRGB_8u_P3AC4R failed\n");
return FALSE;
}
const UINT64 diff = end - start;
char buffer[32] = { 0 };
printf("[%" PRIuz "] YUV420ToRGB_8u_P3AC4R %" PRIu32 "x%" PRIu32 " took %sns\n", x,
bench->roi.width, bench->roi.height, print_time(diff, buffer, sizeof(buffer)));
}
return TRUE;
}
static BOOL primitives_YUV444_benchmark_run(primitives_YUV_benchmark* bench, primitives_t* prims)
{
const BYTE* channels[3] = { 0 };
for (size_t i = 0; i < 3; i++)
channels[i] = bench->channels[i];
for (size_t x = 0; x < 10; x++)
{
const UINT64 start = winpr_GetTickCount64NS();
pstatus_t status =
prims->YUV444ToRGB_8u_P3AC4R(channels, bench->steps, bench->outputBuffer,
bench->outputStride, bench->testedFormat, &bench->roi);
const UINT64 end = winpr_GetTickCount64NS();
if (status != PRIMITIVES_SUCCESS)
{
(void)fprintf(stderr, "Running YUV444ToRGB_8u_P3AC4R failed\n");
return FALSE;
}
const UINT64 diff = end - start;
char buffer[32] = { 0 };
printf("[%" PRIuz "] YUV444ToRGB_8u_P3AC4R %" PRIu32 "x%" PRIu32 " took %sns\n", x,
bench->roi.width, bench->roi.height, print_time(diff, buffer, sizeof(buffer)));
}
return TRUE;
}
static BOOL primitives_RGB2420_benchmark_run(primitives_YUV_benchmark* bench, primitives_t* prims)
{
for (size_t x = 0; x < 10; x++)
{
const UINT64 start = winpr_GetTickCount64NS();
pstatus_t status =
prims->RGBToYUV420_8u_P3AC4R(bench->rgbBuffer, bench->testedFormat, bench->outputStride,
bench->outputChannels, bench->steps, &bench->roi);
const UINT64 end = winpr_GetTickCount64NS();
if (status != PRIMITIVES_SUCCESS)
{
(void)fprintf(stderr, "Running RGBToYUV420_8u_P3AC4R failed\n");
return FALSE;
}
const UINT64 diff = end - start;
char buffer[32] = { 0 };
printf("[%" PRIuz "] RGBToYUV420_8u_P3AC4R %" PRIu32 "x%" PRIu32 " took %sns\n", x,
bench->roi.width, bench->roi.height, print_time(diff, buffer, sizeof(buffer)));
}
return TRUE;
}
static BOOL primitives_RGB2444_benchmark_run(primitives_YUV_benchmark* bench, primitives_t* prims)
{
for (size_t x = 0; x < 10; x++)
{
const UINT64 start = winpr_GetTickCount64NS();
pstatus_t status =
prims->RGBToYUV444_8u_P3AC4R(bench->rgbBuffer, bench->testedFormat, bench->outputStride,
bench->outputChannels, bench->steps, &bench->roi);
const UINT64 end = winpr_GetTickCount64NS();
if (status != PRIMITIVES_SUCCESS)
{
(void)fprintf(stderr, "Running RGBToYUV444_8u_P3AC4R failed\n");
return FALSE;
}
const UINT64 diff = end - start;
char buffer[32] = { 0 };
printf("[%" PRIuz "] RGBToYUV444_8u_P3AC4R %" PRIu32 "x%" PRIu32 " took %sns\n", x,
bench->roi.width, bench->roi.height, print_time(diff, buffer, sizeof(buffer)));
}
return TRUE;
}
int main(int argc, char* argv[])
{
WINPR_UNUSED(argc);
WINPR_UNUSED(argv);
primitives_YUV_benchmark bench = primitives_YUV_benchmark_init();
for (primitive_hints hint = PRIMITIVES_PURE_SOFT; hint < PRIMITIVES_AUTODETECT; hint++)
{
const char* hintstr = primtives_hint_str(hint);
primitives_t* prim = primitives_get_by_type(hint);
if (!prim)
{
(void)fprintf(stderr, "failed to get primitives: %s\n", hintstr);
goto fail;
}
printf("Running YUV420 -> RGB benchmark on %s implementation:\n", hintstr);
if (!primitives_YUV420_benchmark_run(&bench, prim))
{
(void)fprintf(stderr, "YUV420 -> RGB benchmark failed\n");
goto fail;
}
printf("\n");
printf("Running RGB -> YUV420 benchmark on %s implementation:\n", hintstr);
if (!primitives_RGB2420_benchmark_run(&bench, prim))
{
(void)fprintf(stderr, "RGB -> YUV420 benchmark failed\n");
goto fail;
}
printf("\n");
printf("Running YUV444 -> RGB benchmark on %s implementation:\n", hintstr);
if (!primitives_YUV444_benchmark_run(&bench, prim))
{
(void)fprintf(stderr, "YUV444 -> RGB benchmark failed\n");
goto fail;
}
printf("\n");
printf("Running RGB -> YUV444 benchmark on %s implementation:\n", hintstr);
if (!primitives_RGB2444_benchmark_run(&bench, prim))
{
(void)fprintf(stderr, "RGB -> YUV444 benchmark failed\n");
goto fail;
}
printf("\n");
}
fail:
primitives_YUV_benchmark_free(&bench);
return 0;
}

593
libfreerdp/primitives/neon/prim_YUV_neon.c
View File

@@ -35,95 +35,163 @@
static primitives_t* generic = NULL;
static INLINE uint8x8_t neon_YUV2R(int32x4_t Ch, int32x4_t Cl, int16x4_t Dh, int16x4_t Dl,
int16x4_t Eh, int16x4_t El)
static INLINE uint8x8_t neon_YUV2R_single(uint16x8_t C, int16x8_t D, int16x8_t E)
{
/* R = (256 * Y + 403 * (V - 128)) >> 8 */
const int16x4_t c403 = vdup_n_s16(403);
const int32x4_t CEh = vmlal_s16(Ch, Eh, c403);
const int32x4_t CEl = vmlal_s16(Cl, El, c403);
const int32x4_t Rh = vrshrq_n_s32(CEh, 8);
const int32x4_t Rl = vrshrq_n_s32(CEl, 8);
const int16x8_t R = vcombine_s16(vqmovn_s32(Rl), vqmovn_s32(Rh));
return vqmovun_s16(R);
const int32x4_t Ch = vreinterpretq_s32_u32(vmovl_u16(vget_high_u16(C)));
const int32x4_t e403h = vmull_n_s16(vget_high_s16(E), 403);
const int32x4_t cehm = vaddq_s32(Ch, e403h);
const int32x4_t ceh = vshrq_n_s32(cehm, 8);
const int32x4_t Cl = vreinterpretq_s32_u32(vmovl_u16(vget_low_u16(C)));
const int32x4_t e403l = vmull_n_s16(vget_low_s16(E), 403);
const int32x4_t celm = vaddq_s32(Cl, e403l);
const int32x4_t cel = vshrq_n_s32(celm, 8);
const int16x8_t ce = vcombine_s16(vqmovn_s32(cel), vqmovn_s32(ceh));
return vqmovun_s16(ce);
}
static INLINE uint8x8_t neon_YUV2G(int32x4_t Ch, int32x4_t Cl, int16x4_t Dh, int16x4_t Dl,
int16x4_t Eh, int16x4_t El)
static INLINE uint8x8x2_t neon_YUV2R(uint16x8x2_t C, int16x8x2_t D, int16x8x2_t E)
{
uint8x8x2_t res = { { neon_YUV2R_single(C.val[0], D.val[0], E.val[0]),
neon_YUV2R_single(C.val[1], D.val[1], E.val[1]) } };
return res;
}
static INLINE uint8x8_t neon_YUV2G_single(uint16x8_t C, int16x8_t D, int16x8_t E)
{
/* G = (256L * Y - 48 * (U - 128) - 120 * (V - 128)) >> 8 */
const int16x4_t c48 = vdup_n_s16(48);
const int16x4_t c120 = vdup_n_s16(120);
const int32x4_t CDh = vmlsl_s16(Ch, Dh, c48);
const int32x4_t CDl = vmlsl_s16(Cl, Dl, c48);
const int32x4_t CDEh = vmlsl_s16(CDh, Eh, c120);
const int32x4_t CDEl = vmlsl_s16(CDl, El, c120);
const int32x4_t Gh = vrshrq_n_s32(CDEh, 8);
const int32x4_t Gl = vrshrq_n_s32(CDEl, 8);
const int16x8_t G = vcombine_s16(vqmovn_s32(Gl), vqmovn_s32(Gh));
return vqmovun_s16(G);
const int16x8_t d48 = vmulq_n_s16(D, 48);
const int16x8_t e120 = vmulq_n_s16(E, 120);
const int32x4_t deh = vaddl_s16(vget_high_s16(d48), vget_high_s16(e120));
const int32x4_t Ch = vreinterpretq_s32_u32(vmovl_u16(vget_high_u16(C)));
const int32x4_t cdeh32m = vsubq_s32(Ch, deh);
const int32x4_t cdeh32 = vshrq_n_s32(cdeh32m, 8);
const int16x4_t cdeh = vqmovn_s32(cdeh32);
const int32x4_t del = vaddl_s16(vget_low_s16(d48), vget_low_s16(e120));
const int32x4_t Cl = vreinterpretq_s32_u32(vmovl_u16(vget_low_u16(C)));
const int32x4_t cdel32m = vsubq_s32(Cl, del);
const int32x4_t cdel32 = vshrq_n_s32(cdel32m, 8);
const int16x4_t cdel = vqmovn_s32(cdel32);
const int16x8_t cde = vcombine_s16(cdel, cdeh);
return vqmovun_s16(cde);
}
static INLINE uint8x8_t neon_YUV2B(int32x4_t Ch, int32x4_t Cl, int16x4_t Dh, int16x4_t Dl,
int16x4_t Eh, int16x4_t El)
static INLINE uint8x8x2_t neon_YUV2G(uint16x8x2_t C, int16x8x2_t D, int16x8x2_t E)
{
uint8x8x2_t res = { { neon_YUV2G_single(C.val[0], D.val[0], E.val[0]),
neon_YUV2G_single(C.val[1], D.val[1], E.val[1]) } };
return res;
}
static INLINE uint8x8_t neon_YUV2B_single(uint16x8_t C, int16x8_t D, int16x8_t E)
{
/* B = (256L * Y + 475 * (U - 128)) >> 8*/
const int16x4_t c475 = vdup_n_s16(475);
const int32x4_t CDh = vmlal_s16(Ch, Dh, c475);
const int32x4_t CDl = vmlal_s16(Ch, Dl, c475);
const int32x4_t Bh = vrshrq_n_s32(CDh, 8);
const int32x4_t Bl = vrshrq_n_s32(CDl, 8);
const int16x8_t B = vcombine_s16(vqmovn_s32(Bl), vqmovn_s32(Bh));
return vqmovun_s16(B);
const int32x4_t Ch = vreinterpretq_s32_u32(vmovl_u16(vget_high_u16(C)));
const int32x4_t d475h = vmull_n_s16(vget_high_s16(D), 475);
const int32x4_t cdhm = vaddq_s32(Ch, d475h);
const int32x4_t cdh = vshrq_n_s32(cdhm, 8);
const int32x4_t Cl = vreinterpretq_s32_u32(vmovl_u16(vget_low_u16(C)));
const int32x4_t d475l = vmull_n_s16(vget_low_s16(D), 475);
const int32x4_t cdlm = vaddq_s32(Cl, d475l);
const int32x4_t cdl = vshrq_n_s32(cdlm, 8);
const int16x8_t cd = vcombine_s16(vqmovn_s32(cdl), vqmovn_s32(cdh));
return vqmovun_s16(cd);
}
static INLINE BYTE* neon_YuvToRgbPixel(BYTE* pRGB, int16x8_t Y, int16x8_t D, int16x8_t E,
static INLINE uint8x8x2_t neon_YUV2B(uint16x8x2_t C, int16x8x2_t D, int16x8x2_t E)
{
uint8x8x2_t res = { { neon_YUV2B_single(C.val[0], D.val[0], E.val[0]),
neon_YUV2B_single(C.val[1], D.val[1], E.val[1]) } };
return res;
}
static inline void neon_store_bgrx(BYTE* WINPR_RESTRICT pRGB, uint8x8_t r, uint8x8_t g, uint8x8_t b,
uint8_t rPos, uint8_t gPos, uint8_t bPos, uint8_t aPos)
{
uint8x8x4_t bgrx = vld4_u8(pRGB);
bgrx.val[rPos] = r;
bgrx.val[gPos] = g;
bgrx.val[bPos] = b;
vst4_u8(pRGB, bgrx);
}
static INLINE void neon_YuvToRgbPixel(BYTE* pRGB, uint8x8x2_t Y, int16x8x2_t D, int16x8x2_t E,
const uint8_t rPos, const uint8_t gPos, const uint8_t bPos,
const uint8_t aPos)
{
const int32x4_t Ch = vmulq_n_s32(vmovl_s16(vget_high_s16(Y)), 256); /* Y * 256 */
const int32x4_t Cl = vmulq_n_s32(vmovl_s16(vget_low_s16(Y)), 256); /* Y * 256 */
const int16x4_t Dh = vget_high_s16(D);
const int16x4_t Dl = vget_low_s16(D);
const int16x4_t Eh = vget_high_s16(E);
const int16x4_t El = vget_low_s16(E);
uint8x8x4_t bgrx = vld4_u8(pRGB);
/* Y * 256 == Y << 8 */
const uint16x8x2_t C = { { vshlq_n_u16(vmovl_u8(Y.val[0]), 8),
vshlq_n_u16(vmovl_u8(Y.val[1]), 8) } };
const uint8x8x2_t r = neon_YUV2R(C, D, E);
const uint8x8x2_t g = neon_YUV2G(C, D, E);
const uint8x8x2_t b = neon_YUV2B(C, D, E);
neon_store_bgrx(pRGB, r.val[0], g.val[0], b.val[0], rPos, gPos, bPos, aPos);
neon_store_bgrx(pRGB + sizeof(uint8x8x4_t), r.val[1], g.val[1], b.val[1], rPos, gPos, bPos,
aPos);
}
static inline int16x8x2_t loadUV(const BYTE* WINPR_RESTRICT pV, size_t x)
{
const uint8x8_t Vraw = vld1_u8(&pV[x / 2]);
const int16x8_t V = vreinterpretq_s16_u16(vmovl_u8(Vraw));
const int16x8_t c128 = vdupq_n_s16(128);
const int16x8_t E = vsubq_s16(V, c128);
return vzipq_s16(E, E);
}
static INLINE void neon_write_pixel(BYTE* pRGB, BYTE Y, BYTE U, BYTE V, const uint8_t rPos,
const uint8_t gPos, const uint8_t bPos, const uint8_t aPos)
{
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
pRGB[rPos] = r;
pRGB[gPos] = g;
pRGB[bPos] = b;
}
static INLINE pstatus_t neon_YUV420ToX_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pY[2],
const BYTE* WINPR_RESTRICT pU,
const BYTE* WINPR_RESTRICT pV,
BYTE* WINPR_RESTRICT pRGB[2], size_t width,
const uint8_t rPos, const uint8_t gPos,
const uint8_t bPos, const uint8_t aPos)
{
WINPR_ASSERT((width % 2) == 0);
UINT32 x = 0;
for (; x < width - width % 16; x += 16)
{
/* B = (256L * Y + 475 * (U - 128)) >> 8*/
const int16x4_t c475 = vdup_n_s16(475);
const int32x4_t CDh = vmlal_s16(Ch, Dh, c475);
const int32x4_t CDl = vmlal_s16(Cl, Dl, c475);
const int32x4_t Bh = vrshrq_n_s32(CDh, 8);
const int32x4_t Bl = vrshrq_n_s32(CDl, 8);
const int16x8_t B = vcombine_s16(vqmovn_s32(Bl), vqmovn_s32(Bh));
bgrx.val[bPos] = vqmovun_s16(B);
const uint8x16_t Y0raw = vld1q_u8(&pY[0][x]);
const uint8x8x2_t Y0 = { { vget_low_u8(Y0raw), vget_high_u8(Y0raw) } };
const int16x8x2_t D = loadUV(pU, x);
const int16x8x2_t E = loadUV(pV, x);
neon_YuvToRgbPixel(&pRGB[0][4ULL * x], Y0, D, E, rPos, gPos, bPos, aPos);
const uint8x16_t Y1raw = vld1q_u8(&pY[1][x]);
const uint8x8x2_t Y1 = { { vget_low_u8(Y1raw), vget_high_u8(Y1raw) } };
neon_YuvToRgbPixel(&pRGB[1][4ULL * x], Y1, D, E, rPos, gPos, bPos, aPos);
}
for (; x < width; x += 2)
{
/* G = (256L * Y - 48 * (U - 128) - 120 * (V - 128)) >> 8 */
const int16x4_t c48 = vdup_n_s16(48);
const int16x4_t c120 = vdup_n_s16(120);
const int32x4_t CDh = vmlsl_s16(Ch, Dh, c48);
const int32x4_t CDl = vmlsl_s16(Cl, Dl, c48);
const int32x4_t CDEh = vmlsl_s16(CDh, Eh, c120);
const int32x4_t CDEl = vmlsl_s16(CDl, El, c120);
const int32x4_t Gh = vrshrq_n_s32(CDEh, 8);
const int32x4_t Gl = vrshrq_n_s32(CDEl, 8);
const int16x8_t G = vcombine_s16(vqmovn_s32(Gl), vqmovn_s32(Gh));
bgrx.val[gPos] = vqmovun_s16(G);
const BYTE U = pU[x / 2];
const BYTE V = pV[x / 2];
neon_write_pixel(&pRGB[0][4 * x], pY[0][x], U, V, rPos, gPos, bPos, aPos);
neon_write_pixel(&pRGB[0][4 * (1ULL + x)], pY[0][1ULL + x], U, V, rPos, gPos, bPos, aPos);
neon_write_pixel(&pRGB[1][4 * x], pY[1][x], U, V, rPos, gPos, bPos, aPos);
neon_write_pixel(&pRGB[1][4 * (1ULL + x)], pY[1][1ULL + x], U, V, rPos, gPos, bPos, aPos);
}
{
/* R = (256 * Y + 403 * (V - 128)) >> 8 */
const int16x4_t c403 = vdup_n_s16(403);
const int32x4_t CEh = vmlal_s16(Ch, Eh, c403);
const int32x4_t CEl = vmlal_s16(Cl, El, c403);
const int32x4_t Rh = vrshrq_n_s32(CEh, 8);
const int32x4_t Rl = vrshrq_n_s32(CEl, 8);
const int16x8_t R = vcombine_s16(vqmovn_s32(Rl), vqmovn_s32(Rh));
bgrx.val[rPos] = vqmovun_s16(R);
}
vst4_u8(pRGB, bgrx);
pRGB += 32;
return pRGB;
return PRIMITIVES_SUCCESS;
}
static INLINE pstatus_t neon_YUV420ToX(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
@@ -133,113 +201,19 @@ static INLINE pstatus_t neon_YUV420ToX(const BYTE* WINPR_RESTRICT pSrc[3], const
{
const UINT32 nWidth = roi->width;
const UINT32 nHeight = roi->height;
const DWORD pad = nWidth % 16;
const UINT32 yPad = srcStep[0] - roi->width;
const UINT32 uPad = srcStep[1] - roi->width / 2;
const UINT32 vPad = srcStep[2] - roi->width / 2;
const UINT32 dPad = dstStep - roi->width * 4;
const int16x8_t c128 = vdupq_n_s16(128);
WINPR_ASSERT((nHeight % 2) == 0);
for (UINT32 y = 0; y < nHeight; y += 2)
{
const uint8_t* pY1 = pSrc[0] + y * srcStep[0];
const uint8_t* pY2 = pY1 + srcStep[0];
const uint8_t* pY[2] = { pSrc[0] + y * srcStep[0], pSrc[0] + (1ULL + y) * srcStep[0] };
const uint8_t* pU = pSrc[1] + (y / 2) * srcStep[1];
const uint8_t* pV = pSrc[2] + (y / 2) * srcStep[2];
uint8_t* pRGB1 = pDst + y * dstStep;
uint8_t* pRGB2 = pRGB1 + dstStep;
const BOOL lastY = y >= nHeight - 1;
uint8_t* pRGB[2] = { pDst + y * dstStep, pDst + (1ULL + y) * dstStep };
UINT32 x = 0;
for (; x < nWidth - pad;)
{
const uint8x8_t Uraw = vld1_u8(pU);
const uint8x8x2_t Uu = vzip_u8(Uraw, Uraw);
const int16x8_t U1 = vreinterpretq_s16_u16(vmovl_u8(Uu.val[0]));
const int16x8_t U2 = vreinterpretq_s16_u16(vmovl_u8(Uu.val[1]));
const uint8x8_t Vraw = vld1_u8(pV);
const uint8x8x2_t Vu = vzip_u8(Vraw, Vraw);
const int16x8_t V1 = vreinterpretq_s16_u16(vmovl_u8(Vu.val[0]));
const int16x8_t V2 = vreinterpretq_s16_u16(vmovl_u8(Vu.val[1]));
const int16x8_t D1 = vsubq_s16(U1, c128);
const int16x8_t E1 = vsubq_s16(V1, c128);
const int16x8_t D2 = vsubq_s16(U2, c128);
const int16x8_t E2 = vsubq_s16(V2, c128);
{
const uint8x8_t Y1u = vld1_u8(pY1);
const int16x8_t Y1 = vreinterpretq_s16_u16(vmovl_u8(Y1u));
pRGB1 = neon_YuvToRgbPixel(pRGB1, Y1, D1, E1, rPos, gPos, bPos, aPos);
pY1 += 8;
x += 8;
}
{
const uint8x8_t Y1u = vld1_u8(pY1);
const int16x8_t Y1 = vreinterpretq_s16_u16(vmovl_u8(Y1u));
pRGB1 = neon_YuvToRgbPixel(pRGB1, Y1, D2, E2, rPos, gPos, bPos, aPos);
pY1 += 8;
x += 8;
}
if (!lastY)
{
{
const uint8x8_t Y2u = vld1_u8(pY2);
const int16x8_t Y2 = vreinterpretq_s16_u16(vmovl_u8(Y2u));
pRGB2 = neon_YuvToRgbPixel(pRGB2, Y2, D1, E1, rPos, gPos, bPos, aPos);
pY2 += 8;
}
{
const uint8x8_t Y2u = vld1_u8(pY2);
const int16x8_t Y2 = vreinterpretq_s16_u16(vmovl_u8(Y2u));
pRGB2 = neon_YuvToRgbPixel(pRGB2, Y2, D2, E2, rPos, gPos, bPos, aPos);
pY2 += 8;
}
}
pU += 8;
pV += 8;
}
for (; x < nWidth; x++)
{
const BYTE U = *pU;
const BYTE V = *pV;
{
const BYTE Y = *pY1++;
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
pRGB1[rPos] = r;
pRGB1[gPos] = g;
pRGB1[bPos] = b;
pRGB1 += 4;
}
if (!lastY)
{
const BYTE Y = *pY2++;
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
pRGB2[rPos] = r;
pRGB2[gPos] = g;
pRGB2[bPos] = b;
pRGB2 += 4;
}
if (x % 2)
{
pU++;
pV++;
}
}
pRGB1 += dPad;
pRGB2 += dPad;
pY1 += yPad;
pY2 += yPad;
pU += uPad;
pV += vPad;
const pstatus_t rc =
neon_YUV420ToX_DOUBLE_ROW(pY, pU, pV, pRGB, nWidth, rPos, gPos, bPos, aPos);
if (rc != PRIMITIVES_SUCCESS)
return rc;
}
return PRIMITIVES_SUCCESS;
@@ -273,62 +247,163 @@ static pstatus_t neon_YUV420ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
}
}
static inline int16x8_t loadUVreg(uint8x8_t Vraw)
{
const int16x8_t V = vreinterpretq_s16_u16(vmovl_u8(Vraw));
const int16x8_t c128 = vdupq_n_s16(128);
const int16x8_t E = vsubq_s16(V, c128);
return E;
}
static inline int16x8x2_t loadUV444(uint8x16_t Vld)
{
const uint8x8x2_t V = { { vget_low_u8(Vld), vget_high_u8(Vld) } };
const int16x8x2_t res = { {
loadUVreg(V.val[0]),
loadUVreg(V.val[1]),
} };
return res;
}
static inline void avgUV(BYTE U[2][2])
{
const BYTE u00 = U[0][0];
const INT16 umul = (INT16)u00 << 2;
const INT16 sum = (INT16)U[0][1] + U[1][0] + U[1][1];
const INT16 wavg = umul - sum;
const BYTE val = CONDITIONAL_CLIP(wavg, u00);
U[0][0] = val;
}
static inline void neon_avgUV(uint8x16_t pU[2])
{
/* put even and odd values into different registers.
* U 0/0 is in lower half */
const uint8x16x2_t usplit = vuzpq_u8(pU[0], pU[1]);
const uint8x16_t ueven = usplit.val[0];
const uint8x16_t uodd = usplit.val[1];
const uint8x8_t u00 = vget_low_u8(ueven);
const uint8x8_t u01 = vget_low_u8(uodd);
const uint8x8_t u10 = vget_high_u8(ueven);
const uint8x8_t u11 = vget_high_u8(uodd);
/* Create sum of U01 + U10 + U11 */
const uint16x8_t uoddsum = vaddl_u8(u01, u10);
const uint16x8_t usum = vaddq_u16(uoddsum, vmovl_u8(u11));
/* U00 * 4 */
const uint16x8_t umul = vshll_n_u8(u00, 2);
/* U00 - (U01 + U10 + U11) */
const int16x8_t wavg = vsubq_s16(vreinterpretq_s16_u16(umul), vreinterpretq_s16_u16(usum));
const uint8x8_t avg = vqmovun_s16(wavg);
/* abs(u00 - avg) */
const uint8x8_t absdiff = vabd_u8(avg, u00);
/* (diff < 30) ? u00 : avg */
const uint8x8_t mask = vclt_u8(absdiff, vdup_n_u8(30));
/* out1 = u00 & mask */
const uint8x8_t out1 = vand_u8(u00, mask);
/* invmask = ~mask */
const uint8x8_t notmask = vmvn_u8(mask);
/* out2 = avg & invmask */
const uint8x8_t out2 = vand_u8(avg, notmask);
/* out = out1 | out2 */
const uint8x8_t out = vorr_u8(out1, out2);
const uint8x8x2_t ua = vzip_u8(out, u01);
const uint8x16_t u = vcombine_u8(ua.val[0], ua.val[1]);
pU[0] = u;
}
static INLINE pstatus_t neon_YUV444ToX_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pY[2],
const BYTE* WINPR_RESTRICT pU[2],
const BYTE* WINPR_RESTRICT pV[2],
BYTE* WINPR_RESTRICT pRGB[2], size_t width,
const uint8_t rPos, const uint8_t gPos,
const uint8_t bPos, const uint8_t aPos)
{
WINPR_ASSERT(width % 2 == 0);
size_t x = 0;
for (; x < width - width % 16; x += 16)
{
uint8x16_t U[2] = { vld1q_u8(&pU[0][x]), vld1q_u8(&pU[1][x]) };
neon_avgUV(U);
uint8x16_t V[2] = { vld1q_u8(&pV[0][x]), vld1q_u8(&pV[1][x]) };
neon_avgUV(V);
const uint8x16_t Y0raw = vld1q_u8(&pY[0][x]);
const uint8x8x2_t Y0 = { { vget_low_u8(Y0raw), vget_high_u8(Y0raw) } };
const int16x8x2_t D0 = loadUV444(U[0]);
const int16x8x2_t E0 = loadUV444(V[0]);
neon_YuvToRgbPixel(&pRGB[0][4ULL * x], Y0, D0, E0, rPos, gPos, bPos, aPos);
const uint8x16_t Y1raw = vld1q_u8(&pY[1][x]);
const uint8x8x2_t Y1 = { { vget_low_u8(Y1raw), vget_high_u8(Y1raw) } };
const int16x8x2_t D1 = loadUV444(U[1]);
const int16x8x2_t E1 = loadUV444(V[1]);
neon_YuvToRgbPixel(&pRGB[1][4ULL * x], Y1, D1, E1, rPos, gPos, bPos, aPos);
}
for (; x < width; x += 2)
{
BYTE* rgb[2] = { &pRGB[0][x * 4], &pRGB[1][x * 4] };
BYTE U[2][2] = { { pU[0][x], pU[0][x + 1] }, { pU[1][x], pU[1][x + 1] } };
avgUV(U);
BYTE V[2][2] = { { pV[0][x], pV[0][x + 1] }, { pV[1][x], pV[1][x + 1] } };
avgUV(V);
for (size_t i = 0; i < 2; i++)
{
for (size_t j = 0; j < 2; j++)
{
const BYTE y = pY[i][x + j];
const BYTE u = U[i][j];
const BYTE v = V[i][j];
neon_write_pixel(&rgb[i][4 * (j)], y, u, v, rPos, gPos, bPos, aPos);
}
}
}
return PRIMITIVES_SUCCESS;
}
static INLINE pstatus_t neon_YUV444ToX(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
BYTE* WINPR_RESTRICT pDst, UINT32 dstStep,
const prim_size_t* WINPR_RESTRICT roi, const uint8_t rPos,
const uint8_t gPos, const uint8_t bPos, const uint8_t aPos)
{
WINPR_ASSERT(roi);
const UINT32 nWidth = roi->width;
const UINT32 nHeight = roi->height;
const UINT32 yPad = srcStep[0] - roi->width;
const UINT32 uPad = srcStep[1] - roi->width;
const UINT32 vPad = srcStep[2] - roi->width;
const UINT32 dPad = dstStep - roi->width * 4;
const uint8_t* pY = pSrc[0];
const uint8_t* pU = pSrc[1];
const uint8_t* pV = pSrc[2];
uint8_t* pRGB = pDst;
const int16x8_t c128 = vdupq_n_s16(128);
const DWORD pad = nWidth % 8;
for (UINT32 y = 0; y < nHeight; y++)
WINPR_ASSERT(nHeight % 2 == 0);
for (size_t y = 0; y < nHeight; y += 2)
{
for (UINT32 x = 0; x < nWidth - pad; x += 8)
{
const uint8x8_t Yu = vld1_u8(pY);
const int16x8_t Y = vreinterpretq_s16_u16(vmovl_u8(Yu));
const uint8x8_t Uu = vld1_u8(pU);
const int16x8_t U = vreinterpretq_s16_u16(vmovl_u8(Uu));
const uint8x8_t Vu = vld1_u8(pV);
const int16x8_t V = vreinterpretq_s16_u16(vmovl_u8(Vu));
/* Do the calculations on Y in 32bit width, the result of 255 * 256 does not fit
* a signed 16 bit value. */
const int16x8_t D = vsubq_s16(U, c128);
const int16x8_t E = vsubq_s16(V, c128);
pRGB = neon_YuvToRgbPixel(pRGB, Y, D, E, rPos, gPos, bPos, aPos);
pY += 8;
pU += 8;
pV += 8;
}
const uint8_t* WINPR_RESTRICT pY[2] = { pSrc[0] + y * srcStep[0],
pSrc[0] + (y + 1) * srcStep[0] };
const uint8_t* WINPR_RESTRICT pU[2] = { pSrc[1] + y * srcStep[1],
pSrc[1] + (y + 1) * srcStep[1] };
const uint8_t* WINPR_RESTRICT pV[2] = { pSrc[2] + y * srcStep[2],
pSrc[2] + (y + 1) * srcStep[2] };
for (UINT32 x = 0; x < pad; x++)
{
const BYTE Y = *pY++;
const BYTE U = *pU++;
const BYTE V = *pV++;
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
pRGB[rPos] = r;
pRGB[gPos] = g;
pRGB[bPos] = b;
pRGB += 4;
}
uint8_t* WINPR_RESTRICT pRGB[2] = { &pDst[y * dstStep], &pDst[(y + 1) * dstStep] };
pRGB += dPad;
pY += yPad;
pU += uPad;
pV += vPad;
const pstatus_t rc =
neon_YUV444ToX_DOUBLE_ROW(pY, pU, pV, pRGB, nWidth, rPos, gPos, bPos, aPos);
if (rc != PRIMITIVES_SUCCESS)
return rc;
}
return PRIMITIVES_SUCCESS;
@@ -444,87 +519,6 @@ static pstatus_t neon_LumaToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3], const
return PRIMITIVES_SUCCESS;
}
static pstatus_t neon_ChromaFilter(BYTE* WINPR_RESTRICT pDst[3], const UINT32 dstStep[3],
const RECTANGLE_16* WINPR_RESTRICT roi)
{
const UINT32 oddY = 1;
const UINT32 evenY = 0;
const UINT32 nWidth = roi->right - roi->left;
const UINT32 nHeight = roi->bottom - roi->top;
const UINT32 halfHeight = (nHeight + 1) / 2;
const UINT32 halfWidth = (nWidth + 1) / 2;
const UINT32 halfPad = halfWidth % 16;
/* Filter */
for (UINT32 y = roi->top / 2; y < halfHeight + roi->top / 2; y++)
{
const UINT32 val2y = (y * 2 + evenY);
const UINT32 val2y1 = val2y + oddY;
BYTE* pU1 = pDst[1] + dstStep[1] * val2y1;
BYTE* pV1 = pDst[2] + dstStep[2] * val2y1;
BYTE* pU = pDst[1] + dstStep[1] * val2y;
BYTE* pV = pDst[2] + dstStep[2] * val2y;
if (val2y1 > nHeight + roi->top)
continue;
UINT32 x = roi->left / 2;
for (; x < halfWidth + roi->left / 2 - halfPad; x += 8)
{
{
/* U = (U2x,2y << 2) - U2x1,2y - U2x,2y1 - U2x1,2y1 */
uint8x8x2_t u = vld2_u8(&pU[2 * x]);
const int16x8_t up =
vreinterpretq_s16_u16(vshll_n_u8(u.val[0], 2)); /* Ux2,2y << 2 */
const uint8x8x2_t u1 = vld2_u8(&pU1[2 * x]);
const uint16x8_t usub = vaddl_u8(u1.val[1], u1.val[0]); /* U2x,2y1 + U2x1,2y1 */
const int16x8_t us = vreinterpretq_s16_u16(
vaddw_u8(usub, u.val[1])); /* U2x1,2y + U2x,2y1 + U2x1,2y1 */
const int16x8_t un = vsubq_s16(up, us);
const uint8x8_t u8 = vqmovun_s16(un); /* CLIP(un) */
u.val[0] = u8;
vst2_u8(&pU[2 * x], u);
}
{
/* V = (V2x,2y << 2) - V2x1,2y - V2x,2y1 - V2x1,2y1 */
uint8x8x2_t v = vld2_u8(&pV[2 * x]);
const int16x8_t vp =
vreinterpretq_s16_u16(vshll_n_u8(v.val[0], 2)); /* Vx2,2y << 2 */
const uint8x8x2_t v1 = vld2_u8(&pV1[2 * x]);
const uint16x8_t vsub = vaddl_u8(v1.val[1], v1.val[0]); /* V2x,2y1 + V2x1,2y1 */
const int16x8_t vs = vreinterpretq_s16_u16(
vaddw_u8(vsub, v.val[1])); /* V2x1,2y + V2x,2y1 + V2x1,2y1 */
const int16x8_t vn = vsubq_s16(vp, vs);
const uint8x8_t v8 = vqmovun_s16(vn); /* CLIP(vn) */
v.val[0] = v8;
vst2_u8(&pV[2 * x], v);
}
}
for (; x < halfWidth + roi->left / 2; x++)
{
const UINT32 val2x = (x * 2);
const UINT32 val2x1 = val2x + 1;
const BYTE inU = pU[val2x];
const BYTE inV = pV[val2x];
const INT32 up = inU * 4;
const INT32 vp = inV * 4;
INT32 u2020;
INT32 v2020;
if (val2x1 > nWidth + roi->left)
continue;
u2020 = up - pU[val2x1] - pU1[val2x] - pU1[val2x1];
v2020 = vp - pV[val2x1] - pV1[val2x] - pV1[val2x1];
pU[val2x] = CONDITIONAL_CLIP(u2020, inU);
pV[val2x] = CONDITIONAL_CLIP(v2020, inV);
}
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t neon_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDstRaw[3],
const UINT32 dstStep[3],
@@ -612,8 +606,7 @@ static pstatus_t neon_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
}
}
/* Filter */
return neon_ChromaFilter(pDst, dstStep, roi);
return PRIMITIVES_SUCCESS;
}
static pstatus_t neon_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
@@ -697,7 +690,7 @@ static pstatus_t neon_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3], const
}
}
return neon_ChromaFilter(pDst, dstStep, roi);
return PRIMITIVES_SUCCESS;
}
static pstatus_t neon_YUV420CombineToYUV444(avc444_frame_type type,

303
libfreerdp/primitives/opencl/primitives.cl
View File

@@ -25,11 +25,26 @@ uchar clamp_uc(int v, short l, short h)
return (uchar)v;
}
__kernel void yuv420_to_rgba_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
short avgUV(__global const uchar* buf, unsigned stride, unsigned x, unsigned y)
{
const short U00 = buf[y * stride];
if ((x != 0) || (y != 0))
return U00;
const short U01 = buf[y * stride + 1];
const short U10 = buf[(y + 1) * stride];
const short U11 = buf[(y + 1) * stride + 1];
const short avg = U00 * 4 - U01 - U10 - U11;
const short avgU = clamp_uc(avg, 0, 255);
const short diff = abs(U00 - avgU);
if (diff < 30)
return U00;
return avgU;
}
__kernel void yuv420_to_rgba_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -38,7 +53,7 @@ __kernel void yuv420_to_rgba_1b(
short Udim = bufU[(y / 2) * strideU + (x / 2)] - 128;
short Vdim = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -47,16 +62,15 @@ __kernel void yuv420_to_rgba_1b(
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (403 * Vdim)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8 , 0, 255); /* G */
destPtr[1] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (475 * Udim)) >> 8, 0, 255); /* B */
/* A */
}
__kernel void yuv420_to_abgr_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_abgr_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -65,7 +79,7 @@ __kernel void yuv420_to_abgr_1b(
short U = bufU[(y / 2) * strideU + (x / 2)] - 128;
short V = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -75,24 +89,25 @@ __kernel void yuv420_to_abgr_1b(
int y256 = 256 * Y;
/* A */
destPtr[1] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 - (48 * U) - (120 * V)) >> 8, 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
}
__kernel void yuv444_to_abgr_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_abgr_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -101,25 +116,26 @@ __kernel void yuv444_to_abgr_1b(
*/
int y256 = 256 * Y;
/* A */
destPtr[1] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
}
__kernel void yuv444_to_rgba_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_rgba_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -127,17 +143,16 @@ __kernel void yuv444_to_rgba_1b(
* | B | ( | 256 475 0 | | V - 128 | )
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[0] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
/* A */
}
__kernel void yuv420_to_rgbx_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_rgbx_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -146,7 +161,7 @@ __kernel void yuv420_to_rgbx_1b(
short Udim = bufU[(y / 2) * strideU + (x / 2)] - 128;
short Vdim = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -155,16 +170,15 @@ __kernel void yuv420_to_rgbx_1b(
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (403 * Vdim)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8 , 0, 255); /* G */
destPtr[1] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (475 * Udim)) >> 8, 0, 255); /* B */
destPtr[3] = 0xff; /* A */
}
__kernel void yuv420_to_xbgr_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_xbgr_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -173,7 +187,7 @@ __kernel void yuv420_to_xbgr_1b(
short U = bufU[(y / 2) * strideU + (x / 2)] - 128;
short V = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -183,24 +197,25 @@ __kernel void yuv420_to_xbgr_1b(
int y256 = 256 * Y;
destPtr[0] = 0xff; /* A */
destPtr[1] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 - (48 * U) - (120 * V)) >> 8, 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
}
__kernel void yuv444_to_xbgr_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_xbgr_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -210,24 +225,25 @@ __kernel void yuv444_to_xbgr_1b(
int y256 = 256 * Y;
destPtr[0] = 0xff; /* A */
destPtr[1] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[2] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
}
__kernel void yuv444_to_rgbx_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_rgbx_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -235,18 +251,16 @@ __kernel void yuv444_to_rgbx_1b(
* | B | ( | 256 475 0 | | V - 128 | )
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[0] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
destPtr[1] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
destPtr[3] = 0xff; /* A */
}
__kernel void yuv420_to_argb_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_argb_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -255,7 +269,7 @@ __kernel void yuv420_to_argb_1b(
short Udim = bufU[(y / 2) * strideU + (x / 2)] - 128;
short Vdim = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -265,15 +279,14 @@ __kernel void yuv420_to_argb_1b(
int y256 = 256 * Y;
/* A */
destPtr[1] = clamp_uc((y256 + (403 * Vdim)) >> 8, 0, 255); /* R */
destPtr[2] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8, 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (475 * Udim)) >> 8, 0, 255); /* B */
}
__kernel void yuv420_to_bgra_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_bgra_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -282,7 +295,7 @@ __kernel void yuv420_to_bgra_1b(
short U = bufU[(y / 2) * strideU + (x / 2)] - 128;
short V = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -291,25 +304,26 @@ __kernel void yuv420_to_bgra_1b(
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[1] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[1] = clamp_uc((y256 - (48 * U) - (120 * V)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
/* A */
}
__kernel void yuv444_to_bgra_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_bgra_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -317,26 +331,27 @@ __kernel void yuv444_to_bgra_1b(
* | B | ( | 256 475 0 | | V - 128 | )
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[1] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[0] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
destPtr[1] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
/* A */
}
__kernel void yuv444_to_argb_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_argb_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -344,17 +359,16 @@ __kernel void yuv444_to_argb_1b(
* | B | ( | 256 475 0 | | V - 128 | )
*/
int y256 = 256 * Y;
destPtr[3] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[1] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[3] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[1] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
/* A */
}
__kernel void yuv420_to_xrgb_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_xrgb_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -363,7 +377,7 @@ __kernel void yuv420_to_xrgb_1b(
short Udim = bufU[(y / 2) * strideU + (x / 2)] - 128;
short Vdim = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -373,15 +387,14 @@ __kernel void yuv420_to_xrgb_1b(
int y256 = 256 * Y;
destPtr[0] = 0xff; /* A */
destPtr[1] = clamp_uc((y256 + (403 * Vdim)) >> 8, 0, 255); /* R */
destPtr[2] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 - (48 * Udim) - (120 * Vdim)) >> 8, 0, 255); /* G */
destPtr[3] = clamp_uc((y256 + (475 * Udim)) >> 8, 0, 255); /* B */
}
__kernel void yuv420_to_bgrx_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv420_to_bgrx_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
@@ -390,7 +403,7 @@ __kernel void yuv420_to_bgrx_1b(
short U = bufU[(y / 2) * strideU + (x / 2)] - 128;
short V = bufV[(y / 2) * strideV + (x / 2)] - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -399,25 +412,26 @@ __kernel void yuv420_to_bgrx_1b(
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[1] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[1] = clamp_uc((y256 - (48 * U) - (120 * V)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[3] = 0xff; /* A */
}
__kernel void yuv444_to_bgrx_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_bgrx_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -425,26 +439,27 @@ __kernel void yuv444_to_bgrx_1b(
* | B | ( | 256 475 0 | | V - 128 | )
*/
int y256 = 256 * Y;
destPtr[0] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[1] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[0] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
destPtr[1] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[2] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
destPtr[3] = 0xff; /* A */
}
__kernel void yuv444_to_xrgb_1b(
__global const uchar *bufY, unsigned strideY,
__global const uchar *bufU, unsigned strideU,
__global const uchar *bufV, unsigned strideV,
__global uchar *dest, unsigned strideDest)
__kernel void yuv444_to_xrgb_1b(__global const uchar* bufY, unsigned strideY,
__global const uchar* bufU, unsigned strideU,
__global const uchar* bufV, unsigned strideV, __global uchar* dest,
unsigned strideDest)
{
unsigned int x = get_global_id(0);
unsigned int y = get_global_id(1);
short Y = bufY[y * strideY + x];
short U = bufU[y * strideU + x] - 128;
short V = bufV[y * strideV + x] - 128;
short U = avgUV(bufU, strideU, x, y);
short V = avgUV(bufV, strideV, x, y);
short D = U - 128;
short E = V - 128;
__global uchar *destPtr = dest + (strideDest * y) + (x * 4);
__global uchar* destPtr = dest + (strideDest * y) + (x * 4);
/**
* | R | ( | 256 0 403 | | Y | )
@@ -452,8 +467,8 @@ __kernel void yuv444_to_xrgb_1b(
* | B | ( | 256 475 0 | | V - 128 | )
*/
int y256 = 256 * Y;
destPtr[3] = clamp_uc((y256 + (475 * U)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - ( 48 * U) - (120 * V)) >> 8 , 0, 255); /* G */
destPtr[1] = clamp_uc((y256 + (403 * V)) >> 8, 0, 255); /* R */
destPtr[3] = clamp_uc((y256 + (475 * D)) >> 8, 0, 255); /* B */
destPtr[2] = clamp_uc((y256 - (48 * D) - (120 * E)) >> 8, 0, 255); /* G */
destPtr[1] = clamp_uc((y256 + (403 * E)) >> 8, 0, 255); /* R */
destPtr[0] = 0xff; /* A */
}

438
libfreerdp/primitives/prim_YUV.c
View File

@@ -33,8 +33,9 @@
#include "prim_internal.h"
#include "prim_YUV.h"
static pstatus_t general_LumaToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDstRaw[3],
static inline pstatus_t general_LumaToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
const UINT32 srcStep[3],
BYTE* WINPR_RESTRICT pDstRaw[3],
const UINT32 dstStep[3],
const RECTANGLE_16* WINPR_RESTRICT roi)
{
@@ -93,56 +94,9 @@ static pstatus_t general_LumaToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_ChromaFilter(BYTE* WINPR_RESTRICT pDst[3], const UINT32 dstStep[3],
const RECTANGLE_16* WINPR_RESTRICT roi)
{
const UINT32 oddY = 1;
const UINT32 evenY = 0;
const UINT32 nWidth = roi->right - roi->left;
const UINT32 nHeight = roi->bottom - roi->top;
const UINT32 halfHeight = (nHeight + 1) / 2;
const UINT32 halfWidth = (nWidth + 1) / 2;
/* Filter */
for (UINT32 y = roi->top; y < halfHeight + roi->top; y++)
{
const UINT32 val2y = (y * 2 + evenY);
const UINT32 val2y1 = val2y + oddY;
BYTE* pU1 = pDst[1] + 1ULL * dstStep[1] * val2y1;
BYTE* pV1 = pDst[2] + 1ULL * dstStep[2] * val2y1;
BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;
BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;
if (val2y1 > nHeight)
continue;
for (UINT32 x = roi->left; x < halfWidth + roi->left; x++)
{
const UINT32 val2x = (x * 2);
const UINT32 val2x1 = val2x + 1;
const BYTE inU = pU[val2x];
const BYTE inV = pV[val2x];
const INT32 up = inU * 4;
const INT32 vp = inV * 4;
INT32 u2020 = 0;
INT32 v2020 = 0;
if (val2x1 > nWidth)
continue;
u2020 = up - pU[val2x1] - pU1[val2x] - pU1[val2x1];
v2020 = vp - pV[val2x1] - pV1[val2x] - pV1[val2x1];
pU[val2x] = CONDITIONAL_CLIP(u2020, inU);
pV[val2x] = CONDITIONAL_CLIP(v2020, inV);
}
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDstRaw[3],
static inline pstatus_t general_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
const UINT32 srcStep[3],
BYTE* WINPR_RESTRICT pDstRaw[3],
const UINT32 dstStep[3],
const RECTANGLE_16* WINPR_RESTRICT roi)
{
@@ -212,11 +166,10 @@ static pstatus_t general_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
}
}
/* Filter */
return general_ChromaFilter(pDst, dstStep, roi);
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3],
static inline pstatus_t general_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3],
const UINT32 srcStep[3], UINT32 nTotalWidth,
UINT32 nTotalHeight, BYTE* WINPR_RESTRICT pDst[3],
const UINT32 dstStep[3],
@@ -264,7 +217,7 @@ static pstatus_t general_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3],
}
}
return general_ChromaFilter(pDst, dstStep, roi);
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_YUV420CombineToYUV444(avc444_frame_type type,
@@ -307,13 +260,12 @@ general_YUV444SplitToYUV420(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 src
{
UINT32 uY = 0;
UINT32 vY = 0;
UINT32 halfWidth = 0;
UINT32 halfHeight = 0;
/* The auxiliary frame is aligned to multiples of 16x16.
* We need the padded height for B4 and B5 conversion. */
const UINT32 padHeigth = roi->height + 16 - roi->height % 16;
halfWidth = (roi->width + 1) / 2;
halfHeight = (roi->height + 1) / 2;
const UINT32 halfWidth = (roi->width + 1) / 2;
const UINT32 halfHeight = (roi->height + 1) / 2;
/* B1 */
for (size_t y = 0; y < roi->height; y++)
@@ -328,18 +280,13 @@ general_YUV444SplitToYUV420(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 src
{
const BYTE* pSrcU = pSrc[1] + 2ULL * y * srcStep[1];
const BYTE* pSrcV = pSrc[2] + 2ULL * y * srcStep[2];
const BYTE* pSrcU1 = pSrc[1] + (2ULL * y + 1ULL) * srcStep[1];
const BYTE* pSrcV1 = pSrc[2] + (2ULL * y + 1ULL) * srcStep[2];
BYTE* pU = pMainDst[1] + y * dstMainStep[1];
BYTE* pV = pMainDst[2] + y * dstMainStep[2];
for (size_t x = 0; x < halfWidth; x++)
{
/* Filter */
const INT32 u = pSrcU[2 * x] + pSrcU[2 * x + 1] + pSrcU1[2 * x] + pSrcU1[2 * x + 1];
const INT32 v = pSrcV[2 * x] + pSrcV[2 * x + 1] + pSrcV1[2 * x] + pSrcV1[2 * x + 1];
pU[x] = CLIP(u / 4L);
pV[x] = CLIP(v / 4L);
pU[x] = pSrcV[2 * x];
pV[x] = pSrcU[2 * x];
}
}
@@ -388,15 +335,51 @@ general_YUV444SplitToYUV420(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 src
return PRIMITIVES_SUCCESS;
}
static inline pstatus_t
general_YUV444ToRGB_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
const BYTE* WINPR_RESTRICT pY[2], const BYTE* WINPR_RESTRICT pU[2],
const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
{
const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
WINPR_ASSERT(nWidth % 2 == 0);
for (size_t x = 0; x < nWidth; x += 2)
{
for (size_t i = 0; i < 2; i++)
{
for (size_t j = 0; j < 2; j++)
{
const BYTE y = pY[i][x + j];
INT32 u = pU[i][x + j];
INT32 v = pV[i][x + j];
if ((i == 0) && (j == 0))
{
const INT32 subU = (INT32)pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
const INT32 avgU = ((4 * u) - subU);
u = CONDITIONAL_CLIP(avgU, WINPR_ASSERTING_INT_CAST(BYTE, u));
const INT32 subV = (INT32)pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
const INT32 avgV = ((4 * v) - subV);
v = CONDITIONAL_CLIP(avgV, WINPR_ASSERTING_INT_CAST(BYTE, v));
}
const BYTE r = YUV2R(y, u, v);
const BYTE g = YUV2G(y, u, v);
const BYTE b = YUV2B(y, u, v);
pRGB[i] = writePixel(pRGB[i], formatSize, DstFormat, r, g, b, 0);
}
}
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* WINPR_RESTRICT pSrc[3],
const UINT32 srcStep[3],
BYTE* WINPR_RESTRICT pDst, UINT32 dstStep,
UINT32 DstFormat,
const prim_size_t* WINPR_RESTRICT roi)
{
const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
WINPR_ASSERT(pSrc);
WINPR_ASSERT(pDst);
WINPR_ASSERT(roi);
@@ -404,36 +387,65 @@ static pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* WINPR_RESTRIC
const UINT32 nWidth = roi->width;
const UINT32 nHeight = roi->height;
for (size_t y = 0; y < nHeight; y++)
WINPR_ASSERT(nHeight % 2 == 0);
for (size_t y = 0; y < nHeight; y += 2)
{
const BYTE* pY = pSrc[0] + y * srcStep[0];
const BYTE* pU = pSrc[1] + y * srcStep[1];
const BYTE* pV = pSrc[2] + y * srcStep[2];
BYTE* pRGB = pDst + y * dstStep;
const BYTE* WINPR_RESTRICT pY[2] = { pSrc[0] + y * srcStep[0],
pSrc[0] + (y + 1) * srcStep[0] };
const BYTE* WINPR_RESTRICT pU[2] = { pSrc[1] + y * srcStep[1],
pSrc[1] + (y + 1) * srcStep[1] };
const BYTE* WINPR_RESTRICT pV[2] = { pSrc[2] + y * srcStep[2],
pSrc[2] + (y + 1) * srcStep[2] };
BYTE* WINPR_RESTRICT pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
for (size_t x = 0; x < nWidth; x++)
{
const BYTE Y = pY[x];
const BYTE U = pU[x];
const BYTE V = pV[x];
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);
}
pstatus_t rc = general_YUV444ToRGB_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
if (rc != PRIMITIVES_SUCCESS)
return rc;
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_YUV444ToBGRX_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
const BYTE* WINPR_RESTRICT pY[2],
const BYTE* WINPR_RESTRICT pU[2],
const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
{
const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
WINPR_ASSERT(nWidth % 2 == 0);
for (size_t x = 0; x < nWidth; x += 2)
{
const INT32 subU = pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
const INT32 avgU = ((4 * pU[0][x]) - subU);
const BYTE useU = CONDITIONAL_CLIP(avgU, pU[0][x]);
const INT32 subV = pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
const INT32 avgV = ((4 * pV[0][x]) - subV);
const BYTE useV = CONDITIONAL_CLIP(avgV, pV[0][x]);
const BYTE U[2][2] = { { useU, pU[0][x + 1] }, { pU[1][x], pU[1][x + 1] } };
const BYTE V[2][2] = { { useV, pV[0][x + 1] }, { pV[1][x], pV[1][x + 1] } };
for (size_t i = 0; i < 2; i++)
{
for (size_t j = 0; j < 2; j++)
{
const BYTE r = YUV2R(pY[i][x + j], U[i][j], V[i][j]);
const BYTE g = YUV2G(pY[i][x + j], U[i][j], V[i][j]);
const BYTE b = YUV2B(pY[i][x + j], U[i][j], V[i][j]);
pRGB[i] = writePixelBGRX(pRGB[i], formatSize, DstFormat, r, g, b, 0);
}
}
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc[3],
const UINT32 srcStep[3],
BYTE* WINPR_RESTRICT pDst, UINT32 dstStep,
UINT32 DstFormat,
const prim_size_t* WINPR_RESTRICT roi)
{
const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
WINPR_ASSERT(pSrc);
WINPR_ASSERT(pDst);
WINPR_ASSERT(roi);
@@ -441,23 +453,17 @@ static pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT p
const UINT32 nWidth = roi->width;
const UINT32 nHeight = roi->height;
for (size_t y = 0; y < nHeight; y++)
WINPR_ASSERT(nHeight % 2 == 0);
for (size_t y = 0; y < nHeight; y += 2)
{
const BYTE* pY = pSrc[0] + y * srcStep[0];
const BYTE* pU = pSrc[1] + y * srcStep[1];
const BYTE* pV = pSrc[2] + y * srcStep[2];
BYTE* pRGB = pDst + y * dstStep;
const BYTE* pY[2] = { pSrc[0] + y * srcStep[0], pSrc[0] + (y + 1) * srcStep[0] };
const BYTE* pU[2] = { pSrc[1] + y * srcStep[1], pSrc[1] + (y + 1) * srcStep[1] };
const BYTE* pV[2] = { pSrc[2] + y * srcStep[2], pSrc[2] + (y + 1) * srcStep[2] };
BYTE* pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
for (size_t x = 0; x < nWidth; x++)
{
const BYTE Y = pY[x];
const BYTE U = pU[x];
const BYTE V = pV[x];
const BYTE r = YUV2R(Y, U, V);
const BYTE g = YUV2G(Y, U, V);
const BYTE b = YUV2B(Y, U, V);
pRGB = writePixelBGRX(pRGB, formatSize, DstFormat, r, g, b, 0);
}
pstatus_t rc = general_YUV444ToBGRX_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
if (rc != PRIMITIVES_SUCCESS)
return rc;
}
return PRIMITIVES_SUCCESS;
@@ -612,65 +618,173 @@ static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3
return PRIMITIVES_SUCCESS;
}
/**
* | Y | ( | 54 183 18 | | R | ) | 0 |
* | U | = ( | -29 -99 128 | | G | ) >> 8 + | 128 |
* | V | ( | 128 -116 -12 | | B | ) | 128 |
*/
static INLINE BYTE RGB2Y(INT32 R, INT32 G, INT32 B)
static void BGRX_fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2],
BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
BYTE* WINPR_RESTRICT pV[2])
{
const INT32 val = ((54 * R + 183 * G + 18 * B) >> 8);
return WINPR_ASSERTING_INT_CAST(BYTE, val);
}
WINPR_ASSERT(pRGB);
WINPR_ASSERT(pY);
WINPR_ASSERT(pU);
WINPR_ASSERT(pV);
static INLINE BYTE RGB2U(INT32 R, INT32 G, INT32 B)
{
const INT32 val = (((-29 * R - 99 * G + 128 * B) >> 8) + 128);
return WINPR_ASSERTING_INT_CAST(BYTE, val);
}
const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
const UINT32 bpp = 4;
static INLINE BYTE RGB2V(INT32 R, INT32 G, INT32 B)
{
const INT32 val = (((128 * R - 116 * G - 12 * B) >> 8) + 128);
return WINPR_ASSERTING_INT_CAST(BYTE, val);
}
// NOLINTBEGIN(readability-non-const-parameter)
static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
UINT32 dstStep[3],
const prim_size_t* WINPR_RESTRICT roi)
// NOLINTEND(readability-non-const-parameter)
{
const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
UINT32 nWidth = 0;
UINT32 nHeight = 0;
nWidth = roi->width;
nHeight = roi->height;
for (size_t y = 0; y < nHeight; y++)
for (size_t i = 0; i < 2; i++)
{
const BYTE* pRGB = pSrc + y * srcStep;
BYTE* pY = pDst[0] + y * dstStep[0];
BYTE* pU = pDst[1] + y * dstStep[1];
BYTE* pV = pDst[2] + y * dstStep[2];
for (size_t x = 0; x < nWidth; x++)
for (size_t j = 0; j < 2; j++)
{
BYTE B = 0;
BYTE G = 0;
BYTE R = 0;
const UINT32 color = FreeRDPReadColor(&pRGB[x * bpp], SrcFormat);
const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
pY[x] = RGB2Y(R, G, B);
pU[x] = RGB2U(R, G, B);
pV[x] = RGB2V(R, G, B);
pY[i][offset + j] = RGB2Y(R, G, B);
pU[i][offset + j] = RGB2U(R, G, B);
pV[i][offset + j] = RGB2V(R, G, B);
}
}
/* Apply chroma filter */
const INT32 avgU = (pU[0][offset] + pU[0][offset + 1] + pU[1][offset] + pU[1][offset + 1]) / 4;
pU[0][offset] = CONDITIONAL_CLIP(avgU, pU[0][offset]);
const INT32 avgV = (pV[0][offset] + pV[0][offset + 1] + pV[1][offset] + pV[1][offset + 1]) / 4;
pV[0][offset] = CONDITIONAL_CLIP(avgV, pV[0][offset]);
}
static inline pstatus_t general_BGRXToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
BYTE* WINPR_RESTRICT pY[2],
BYTE* WINPR_RESTRICT pU[2],
BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
{
WINPR_ASSERT((nWidth % 2) == 0);
for (size_t x = 0; x < nWidth; x += 2)
{
BGRX_fillYUV(x, pRGB, pY, pU, pV);
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_RGBToYUV444_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc,
const UINT32 srcStep,
BYTE* WINPR_RESTRICT pDst[3],
const UINT32 dstStep[3],
const prim_size_t* WINPR_RESTRICT roi)
{
const UINT32 nWidth = roi->width;
const UINT32 nHeight = roi->height;
WINPR_ASSERT((nHeight % 2) == 0);
for (size_t y = 0; y < nHeight; y += 2)
{
const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
BYTE* pY[] = { pDst[0] + y * dstStep[0], pDst[0] + (y + 1) * dstStep[0] };
BYTE* pU[] = { pDst[1] + y * dstStep[1], pDst[1] + (y + 1) * dstStep[1] };
BYTE* pV[] = { pDst[2] + y * dstStep[2], pDst[2] + (y + 1) * dstStep[2] };
const pstatus_t rc = general_BGRXToYUV444_DOUBLE_ROW(pRGB, pY, pU, pV, nWidth);
if (rc != PRIMITIVES_SUCCESS)
return rc;
}
return PRIMITIVES_SUCCESS;
}
static void fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2], UINT32 SrcFormat,
BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
BYTE* WINPR_RESTRICT pV[2])
{
WINPR_ASSERT(pRGB);
WINPR_ASSERT(pY);
WINPR_ASSERT(pU);
WINPR_ASSERT(pV);
const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
INT32 avgU = 0;
INT32 avgV = 0;
for (size_t i = 0; i < 2; i++)
{
for (size_t j = 0; j < 2; j++)
{
BYTE B = 0;
BYTE G = 0;
BYTE R = 0;
const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
const BYTE y = RGB2Y(R, G, B);
const BYTE u = RGB2U(R, G, B);
const BYTE v = RGB2V(R, G, B);
avgU += u;
avgV += v;
pY[i][offset + j] = y;
pU[i][offset + j] = u;
pV[i][offset + j] = v;
}
}
/* Apply chroma filter */
avgU /= 4;
pU[0][offset] = CLIP(avgU);
avgV /= 4;
pV[0][offset] = CLIP(avgV);
}
static inline pstatus_t general_RGBToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
UINT32 SrcFormat, BYTE* WINPR_RESTRICT pY[2],
BYTE* WINPR_RESTRICT pU[2],
BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
{
WINPR_ASSERT((nWidth % 2) == 0);
for (size_t x = 0; x < nWidth; x += 2)
{
fillYUV(x, pRGB, SrcFormat, pY, pU, pV);
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_RGBToYUV444_8u_P3AC4R_RGB(const BYTE* WINPR_RESTRICT pSrc,
UINT32 SrcFormat, const UINT32 srcStep,
BYTE* WINPR_RESTRICT pDst[3],
const UINT32 dstStep[3],
const prim_size_t* WINPR_RESTRICT roi)
{
const UINT32 nWidth = roi->width;
const UINT32 nHeight = roi->height;
WINPR_ASSERT((nHeight % 2) == 0);
for (size_t y = 0; y < nHeight; y += 2)
{
const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
BYTE* pY[] = { &pDst[0][y * dstStep[0]], &pDst[0][(y + 1) * dstStep[0]] };
BYTE* pU[] = { &pDst[1][y * dstStep[1]], &pDst[1][(y + 1) * dstStep[1]] };
BYTE* pV[] = { &pDst[2][y * dstStep[2]], &pDst[2][(y + 1) * dstStep[2]] };
const pstatus_t rc = general_RGBToYUV444_DOUBLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
if (rc != PRIMITIVES_SUCCESS)
return rc;
}
return PRIMITIVES_SUCCESS;
}
static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
const UINT32 dstStep[3],
const prim_size_t* WINPR_RESTRICT roi)
{
switch (SrcFormat)
{
case PIXEL_FORMAT_BGRA32:
case PIXEL_FORMAT_BGRX32:
return general_RGBToYUV444_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, roi);
default:
return general_RGBToYUV444_8u_P3AC4R_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
}
}
static INLINE pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
BYTE* WINPR_RESTRICT pDst[3],
const UINT32 dstStep[3],
@@ -941,14 +1055,18 @@ static pstatus_t general_RGBToYUV420_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc,
}
}
static INLINE void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(size_t offset, const BYTE* WINPR_RESTRICT pSrcEven,
const BYTE* WINPR_RESTRICT pSrcOdd,
BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd,
BYTE* WINPR_RESTRICT b2, BYTE* WINPR_RESTRICT b3,
BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7,
UINT32 width)
{
for (UINT32 x = 0; x < width; x += 2)
for (size_t x = offset; x < width; x += 2)
{
const BYTE* srcEven = &pSrcEven[4ULL * x];
const BYTE* srcOdd = &pSrcOdd[4ULL * x];
const BOOL lastX = (x + 1) >= width;
BYTE Y1e = 0;
BYTE Y2e = 0;
@@ -1075,8 +1193,8 @@ static INLINE pstatus_t general_RGBToAVC444YUV_BGRX(const BYTE* WINPR_RESTRICT p
BYTE* b5 = b4 + 8ULL * dst2Step[0];
BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5, b6,
b7, roi->width);
general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5,
b6, b7, roi->width);
}
return PRIMITIVES_SUCCESS;
@@ -1695,8 +1813,8 @@ static INLINE pstatus_t general_RGBToAVC444YUVv2_ANY(
return PRIMITIVES_SUCCESS;
}
static INLINE void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
@@ -1704,8 +1822,10 @@ static INLINE void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
{
for (UINT32 x = 0; x < width; x += 2)
for (size_t x = offset; x < width; x += 2)
{
const BYTE* srcEven = &pSrcEven[4ULL * x];
const BYTE* srcOdd = &pSrcOdd[4ULL * x];
BYTE Ya = 0;
BYTE Ua = 0;
BYTE Va = 0;
@@ -1854,7 +1974,7 @@ static INLINE pstatus_t general_RGBToAVC444YUVv2_BGRX(const BYTE* WINPR_RESTRICT
BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
0, srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1, dstChromaU2, dstChromaV1,
dstChromaV2, roi->width);
}
@@ -1898,6 +2018,6 @@ void primitives_init_YUV(primitives_t* WINPR_RESTRICT prims)
void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims)
{
primitives_init_YUV_ssse3(prims);
primitives_init_YUV_sse41(prims);
primitives_init_YUV_neon(prims);
}

2
libfreerdp/primitives/prim_YUV.h
View File

@@ -25,7 +25,7 @@
#include <freerdp/config.h>
#include <freerdp/primitives.h>
void primitives_init_YUV_ssse3(primitives_t* WINPR_RESTRICT prims);
void primitives_init_YUV_sse41(primitives_t* WINPR_RESTRICT prims);
void primitives_init_YUV_neon(primitives_t* WINPR_RESTRICT prims);
#endif

51
libfreerdp/primitives/prim_internal.h
View File

@@ -52,6 +52,17 @@ static inline __m128i mm_set_epu32(uint32_t val1, uint32_t val2, uint32_t val3,
return _mm_set_epi32((int32_t)val1, (int32_t)val2, (int32_t)val3, (int32_t)val4);
}
static inline __m128i mm_set_epu8(uint8_t val1, uint8_t val2, uint8_t val3, uint8_t val4,
uint8_t val5, uint8_t val6, uint8_t val7, uint8_t val8,
uint8_t val9, uint8_t val10, uint8_t val11, uint8_t val12,
uint8_t val13, uint8_t val14, uint8_t val15, uint8_t val16)
{
return _mm_set_epi8((int8_t)val1, (int8_t)val2, (int8_t)val3, (int8_t)val4, (int8_t)val5,
(int8_t)val6, (int8_t)val7, (int8_t)val8, (int8_t)val9, (int8_t)val10,
(int8_t)val11, (int8_t)val12, (int8_t)val13, (int8_t)val14, (int8_t)val15,
(int8_t)val16);
}
static inline __m128i mm_set1_epu32(uint32_t val)
{
return _mm_set1_epi32((int32_t)val);
@@ -286,6 +297,44 @@ static INLINE BYTE YUV2B(INT32 Y, INT32 U, INT32 V)
return CLIP(b8);
}
/**
* | Y | ( | 54 183 18 | | R | ) | 0 |
* | U | = ( | -29 -99 128 | | G | ) >> 8 + | 128 |
* | V | ( | 128 -116 -12 | | B | ) | 128 |
*/
static INLINE BYTE RGB2Y(INT32 R, INT32 G, INT32 B)
{
const INT32 val = ((54 * R + 183 * G + 18 * B) >> 8);
return WINPR_ASSERTING_INT_CAST(BYTE, val);
}
static INLINE BYTE RGB2U(INT32 R, INT32 G, INT32 B)
{
const INT32 val = (((-29 * R - 99 * G + 128 * B) >> 8) + 128);
return WINPR_ASSERTING_INT_CAST(BYTE, val);
}
static INLINE BYTE RGB2V(INT32 R, INT32 G, INT32 B)
{
const INT32 val = (((128 * R - 116 * G - 12 * B) >> 8) + 128);
return WINPR_ASSERTING_INT_CAST(BYTE, val);
}
FREERDP_LOCAL void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
size_t offset, const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width);
FREERDP_LOCAL void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width);
/* Function prototypes for all the init/deinit routines. */
FREERDP_LOCAL void primitives_init_copy(primitives_t* WINPR_RESTRICT prims);
FREERDP_LOCAL void primitives_init_set(primitives_t* WINPR_RESTRICT prims);
@@ -313,6 +362,4 @@ FREERDP_LOCAL void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims);
FREERDP_LOCAL BOOL primitives_init_opencl(primitives_t* WINPR_RESTRICT prims);
#endif
FREERDP_LOCAL primitives_t* primitives_get_by_type(DWORD type);
#endif /* FREERDP_LIB_PRIM_INTERNAL_H */

34
libfreerdp/primitives/primitives.c
View File

@@ -382,7 +382,7 @@ primitives_t* primitives_get_generic(void)
return &pPrimitivesGeneric;
}
primitives_t* primitives_get_by_type(DWORD type)
primitives_t* primitives_get_by_type(primitive_hints type)
{
InitOnceExecuteOnce(&generic_primitives_InitOnce, primitives_init_generic_cb, NULL, NULL);
@@ -410,3 +410,35 @@ DWORD primitives_flags(primitives_t* p)
{
return p->flags;
}
const char* primitives_avc444_frame_type_str(avc444_frame_type type)
{
switch (type)
{
case AVC444_LUMA:
return "AVC444_LUMA";
case AVC444_CHROMAv1:
return "AVC444_CHROMAv1";
case AVC444_CHROMAv2:
return "AVC444_CHROMAv2";
default:
return "INVALID_FRAME_TYPE";
}
}
const char* primtives_hint_str(primitive_hints hint)
{
switch (hint)
{
case PRIMITIVES_PURE_SOFT:
return "PRIMITIVES_PURE_SOFT";
case PRIMITIVES_ONLY_CPU:
return "PRIMITIVES_ONLY_CPU";
case PRIMITIVES_ONLY_GPU:
return "PRIMITIVES_ONLY_GPU";
case PRIMITIVES_AUTODETECT:
return "PRIMITIVES_AUTODETECT";
default:
return "PRIMITIVES_UNKNOWN";
}
}

714
libfreerdp/primitives/sse/prim_YUV_ssse3.c → libfreerdp/primitives/sse/prim_YUV_sse4.1.c
View File

File diff suppressed because it is too large Load Diff

6
libfreerdp/primitives/sse/prim_copy_sse4_1.c
View File

@@ -34,12 +34,6 @@
#include <emmintrin.h>
#include <immintrin.h>
static INLINE pstatus_t sse_image_copy_no_overlap_convert(
BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
SSIZE_T srcVMultiplier, SSIZE_T srcVOffset, SSIZE_T dstVMultiplier, SSIZE_T dstVOffset);
static INLINE pstatus_t sse_image_copy_bgr24_bgrx32(BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep,
UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
UINT32 nHeight,

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

@@ -1,15 +1,20 @@
#include <freerdp/config.h>
#include <stdlib.h>
#include <math.h>
#include "prim_test.h"
#include <winpr/print.h>
#include <winpr/wlog.h>
#include <winpr/crypto.h>
#include <freerdp/primitives.h>
#include <freerdp/utils/profiler.h>
#include "../prim_internal.h"
#define TAG __FILE__
#define PADDING_FILL_VALUE 0x37
@@ -33,7 +38,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 +66,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 +396,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 +483,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 +587,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 +606,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 +650,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;
@@ -668,19 +691,19 @@ static BOOL compare_yuv420(BYTE** planesA, BYTE** planesB, UINT32 width, UINT32
if (check_for_mismatches(planesA[0], planesB[0], size))
{
(void)fprintf(stderr, "Mismatch in Y planes!");
(void)fprintf(stderr, "Mismatch in Y planes!\n");
rc = FALSE;
}
if (check_for_mismatches(planesA[1], planesB[1], uvsize))
{
(void)fprintf(stderr, "Mismatch in U planes!");
(void)fprintf(stderr, "Mismatch in U planes!\n");
rc = FALSE;
}
if (check_for_mismatches(planesA[2], planesB[2], uvsize))
{
(void)fprintf(stderr, "Mismatch in V planes!");
(void)fprintf(stderr, "Mismatch in V planes!\n");
rc = FALSE;
}
@@ -778,27 +801,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 +887,7 @@ static BOOL TestPrimitiveRgbToLumaChroma(primitives_t* prims, prim_size_t roi, U
res = TRUE;
fail:
printf("[%s][version %u] run %s.\n", __func__, (unsigned)version, (res) ? "SUCCESS" : "FAILED");
free_padding(rgb, padding);
free_yuv420(luma, padding);
free_yuv420(chroma, padding);
@@ -885,17 +896,497 @@ 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 = 0;
BYTE g1 = 0;
BYTE b1 = 0;
FreeRDPSplitColor(color1, format, &r1, &g1, &b1, NULL, NULL);
BYTE r2 = 0;
BYTE g2 = 0;
BYTE b2 = 0;
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))
{
(void)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);
(void)fprintf(stderr, "roi: %dx%d\n", roi.width, roi.height);
winpr_HexDump("y0", WLOG_INFO, &yline[0][x], 16);
winpr_HexDump("y1", WLOG_INFO, &yline[0][x + roi.width], 16);
winpr_HexDump("u0", WLOG_INFO, &yline[1][x], 16);
winpr_HexDump("u1", WLOG_INFO, &yline[1][x + roi.width], 16);
winpr_HexDump("v0", WLOG_INFO, &yline[2][x], 16);
winpr_HexDump("v1", WLOG_INFO, &yline[2][x + roi.width], 16);
winpr_HexDump("foo1", WLOG_INFO, &line1[x * 4], 16);
winpr_HexDump("foo2", WLOG_INFO, &line2[x * 4], 16);
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)
{
(void)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 = 0;
BYTE g1 = 0;
BYTE b1 = 0;
FreeRDPSplitColor(color1, format, &r1, &g1, &b1, NULL, NULL);
BYTE r2 = 0;
BYTE g2 = 0;
BYTE b2 = 0;
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;
}
static BOOL similarYUV(const BYTE* line1, const BYTE* line2, size_t len)
{
for (size_t x = 0; x < len; x++)
{
const int a = line1[x];
const int b = line2[x];
const int diff = abs(a - b);
if (diff >= 2)
return FALSE;
return TRUE;
}
}
/* Due to optimizations the Y value might be off by +/- 1 */
static int similarY(const BYTE* a, const BYTE* b, size_t size, size_t type)
{
switch (type)
{
case 0:
case 1:
case 2:
for (size_t x = 0; x < size; x++)
{
const int ba = a[x];
const int bb = b[x];
const int diff = abs(ba - bb);
if (diff > 2)
return diff;
}
return 0;
break;
default:
return memcmp(a, b, size);
}
}
/* 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 (similarY(yline1[x], yline2[x], yuvStep[x], x) != 0)
{
(void)fprintf(stderr,
"[%s] compare failed in component %" PRIuz ", line %" PRIuz "\n",
__func__, x, y);
(void)fprintf(stderr, "[%s] roi %" PRIu32 "x%" PRIu32 "\n", __func__, roi.width,
roi.height);
winpr_HexDump(TAG, WLOG_WARN, yline1[x], yuvStep[x]);
winpr_HexDump(TAG, WLOG_WARN, yline2[x], yuvStep[x]);
winpr_HexDump(TAG, WLOG_WARN, &rgb[y * stride], stride);
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();
for (UINT32 x = 0; x < 5; x++)
{
prim_size_t roi = { 0 };
if (argc > 1)
@@ -912,81 +1403,26 @@ int TestPrimitivesYUV(int argc, char* argv[])
else
get_size(large, &roi.width, &roi.height);
printf("-------------------- GENERIC ------------------------\n");
prim_test_setup(FALSE);
if (!TestPrimitiveYUV(generic, roi, TRUE))
for (UINT32 type = PRIMITIVES_PURE_SOFT; type <= PRIMITIVES_AUTODETECT; type++)
{
printf("TestPrimitiveYUV (444) failed.\n");
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;
}
printf("---------------------- END --------------------------\n");
printf("------------------- OPTIMIZED -----------------------\n");
if (!TestPrimitiveYUV(prims, roi, TRUE))
{
printf("TestPrimitiveYUV (444) failed.\n");
if (!run_tests(roi))
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");
}
rc = 0;
end:
printf("[%s] finished, status %s [%d]\n", __func__, (rc == 0) ? "SUCCESS" : "FAILURE", rc);
return rc;
}

1
scripts/codespell.sh
View File

@@ -8,6 +8,7 @@ SCRIPT_PATH=$(realpath "$SCRIPT_PATH")
# 1. All words consisting of only 2 characters (too many issues with variable names)
# 2. Every word of the form 'pEvent', e.g. variable prefixed with p for pointer
# 3. Every word prefixed by e.g. '\tSome text', e.g. format string escapes
codespell --version
codespell \
-I "$SCRIPT_PATH/codespell.ignore" \
-S ".git,*.ai,*.svg,*.rtf,*/assets/de_*,*/res/values-*,*/protocols/xdg*,*/test/*" \

5
winpr/include/winpr/sysinfo.h
View File

@@ -31,8 +31,9 @@ extern "C"
{
#endif
#ifndef _WIN32
#ifdef _WIN32
#include <winnt.h>
#else
#define PROCESSOR_ARCHITECTURE_INTEL 0
#define PROCESSOR_ARCHITECTURE_MIPS 1
#define PROCESSOR_ARCHITECTURE_ALPHA 2