1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
/* prim_internal.h
* vi:ts=4 sw=4
*
* (c) Copyright 2012 Hewlett-Packard Development Company, L.P.
* 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. Algorithms used by
* this code may be covered by patents by HP, Microsoft, or other parties.
*
*/
#ifndef FREERDP_LIB_PRIM_INTERNAL_H
#define FREERDP_LIB_PRIM_INTERNAL_H
#include <freerdp/config.h>
#include <freerdp/primitives.h>
#include <freerdp/api.h>
#ifdef __GNUC__
#define PRIM_ALIGN_128 __attribute__((aligned(16)))
#else
#ifdef _WIN32
#define PRIM_ALIGN_128 __declspec(align(16))
#endif
#endif
#if defined(WITH_SSE2) || defined(WITH_NEON) || defined(WITH_OPENCL)
#define HAVE_OPTIMIZED_PRIMITIVES 1
#endif
#if defined(WITH_SSE2) || defined(WITH_NEON)
#define HAVE_CPU_OPTIMIZED_PRIMITIVES 1
#endif
#if defined(WITH_SSE2)
/* Use lddqu for unaligned; load for 16-byte aligned. */
#define LOAD_SI128(_ptr_) \
(((const ULONG_PTR)(_ptr_)&0x0f) ? _mm_lddqu_si128((const __m128i*)(_ptr_)) \
: _mm_load_si128((const __m128i*)(_ptr_)))
#endif
static INLINE BYTE* writePixelBGRA(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
*dst++ = B;
*dst++ = G;
*dst++ = R;
*dst++ = A;
return dst;
}
static INLINE BYTE* writePixelBGRX(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
WINPR_UNUSED(A);
*dst++ = B;
*dst++ = G;
*dst++ = R;
dst++; /* Do not touch alpha */
return dst;
}
static INLINE BYTE* writePixelRGBA(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
*dst++ = R;
*dst++ = G;
*dst++ = B;
*dst++ = A;
return dst;
}
static INLINE BYTE* writePixelRGBX(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
WINPR_UNUSED(A);
*dst++ = R;
*dst++ = G;
*dst++ = B;
dst++; /* Do not touch alpha */
return dst;
}
static INLINE BYTE* writePixelABGR(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
*dst++ = A;
*dst++ = B;
*dst++ = G;
*dst++ = R;
return dst;
}
static INLINE BYTE* writePixelXBGR(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
WINPR_UNUSED(A);
dst++; /* Do not touch alpha */
*dst++ = B;
*dst++ = G;
*dst++ = R;
return dst;
}
static INLINE BYTE* writePixelARGB(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
*dst++ = A;
*dst++ = R;
*dst++ = G;
*dst++ = B;
return dst;
}
static INLINE BYTE* writePixelXRGB(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
WINPR_UNUSED(formatSize);
WINPR_UNUSED(format);
WINPR_UNUSED(A);
dst++; /* Do not touch alpha */
*dst++ = R;
*dst++ = G;
*dst++ = B;
return dst;
}
static INLINE BYTE* writePixelGenericAlpha(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R,
BYTE G, BYTE B, BYTE A)
{
UINT32 color = FreeRDPGetColor(format, R, G, B, A);
FreeRDPWriteColor(dst, format, color);
return dst + formatSize;
}
static INLINE BYTE* writePixelGeneric(BYTE* dst, DWORD formatSize, UINT32 format, BYTE R, BYTE G,
BYTE B, BYTE A)
{
UINT32 color = FreeRDPGetColor(format, R, G, B, A);
FreeRDPWriteColorIgnoreAlpha(dst, format, color);
return dst + formatSize;
}
typedef BYTE* (*fkt_writePixel)(BYTE*, DWORD, UINT32, BYTE, BYTE, BYTE, BYTE);
static INLINE fkt_writePixel getPixelWriteFunction(DWORD format, BOOL useAlpha)
{
switch (format)
{
case PIXEL_FORMAT_ARGB32:
case PIXEL_FORMAT_XRGB32:
return useAlpha ? writePixelARGB : writePixelXRGB;
case PIXEL_FORMAT_ABGR32:
case PIXEL_FORMAT_XBGR32:
return useAlpha ? writePixelABGR : writePixelXBGR;
case PIXEL_FORMAT_RGBA32:
case PIXEL_FORMAT_RGBX32:
return useAlpha ? writePixelRGBA : writePixelRGBX;
case PIXEL_FORMAT_BGRA32:
case PIXEL_FORMAT_BGRX32:
return useAlpha ? writePixelBGRA : writePixelBGRX;
default:
return useAlpha ? writePixelGenericAlpha : writePixelGeneric;
}
}
static INLINE BYTE CLIP(INT64 X)
{
if (X > 255L)
return 255L;
if (X < 0L)
return 0L;
return (BYTE)X;
}
static INLINE BYTE CONDITIONAL_CLIP(INT32 in, BYTE original)
{
BYTE out = CLIP(in);
BYTE diff;
if (out > original)
diff = out - original;
else
diff = original - out;
if (diff < 30)
return original;
return out;
}
/**
* | R | ( | 256 0 403 | | Y | )
* | G | = ( | 256 -48 -120 | | U - 128 | ) >> 8
* | B | ( | 256 475 0 | | V - 128 | )
*/
static INLINE INT32 C(INT32 Y)
{
return (Y)-0L;
}
static INLINE INT32 D(INT32 U)
{
return (U)-128L;
}
static INLINE INT32 E(INT32 V)
{
return (V)-128L;
}
static INLINE BYTE YUV2R(INT32 Y, INT32 U, INT32 V)
{
const INT32 r = (256L * C(Y) + 0L * D(U) + 403L * E(V));
const INT32 r8 = r >> 8L;
return CLIP(r8);
}
static INLINE BYTE YUV2G(INT32 Y, INT32 U, INT32 V)
{
const INT32 g = (256L * C(Y) - 48L * D(U) - 120L * E(V));
const INT32 g8 = g >> 8L;
return CLIP(g8);
}
static INLINE BYTE YUV2B(INT32 Y, INT32 U, INT32 V)
{
const INT32 b = (256L * C(Y) + 475L * D(U) + 0L * E(V));
const INT32 b8 = b >> 8L;
return CLIP(b8);
}
/* Function prototypes for all the init/deinit routines. */
FREERDP_LOCAL void primitives_init_copy(primitives_t* prims);
FREERDP_LOCAL void primitives_init_set(primitives_t* prims);
FREERDP_LOCAL void primitives_init_add(primitives_t* prims);
FREERDP_LOCAL void primitives_init_andor(primitives_t* prims);
FREERDP_LOCAL void primitives_init_shift(primitives_t* prims);
FREERDP_LOCAL void primitives_init_sign(primitives_t* prims);
FREERDP_LOCAL void primitives_init_alphaComp(primitives_t* prims);
FREERDP_LOCAL void primitives_init_colors(primitives_t* prims);
FREERDP_LOCAL void primitives_init_YCoCg(primitives_t* prims);
FREERDP_LOCAL void primitives_init_YUV(primitives_t* prims);
#if defined(WITH_SSE2) || defined(WITH_NEON)
FREERDP_LOCAL void primitives_init_copy_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_set_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_add_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_andor_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_shift_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_sign_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_alphaComp_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_colors_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_YCoCg_opt(primitives_t* prims);
FREERDP_LOCAL void primitives_init_YUV_opt(primitives_t* prims);
#endif
#if defined(WITH_OPENCL)
FREERDP_LOCAL BOOL primitives_init_opencl(primitives_t* prims);
#endif
FREERDP_LOCAL primitives_t* primitives_get_by_type(DWORD type);
#endif /* FREERDP_LIB_PRIM_INTERNAL_H */
|
