FreeRDP
Loading...
Searching...
No Matches
prim_YUV.c
1
24#include <winpr/wtypes.h>
25#include <winpr/assert.h>
26#include <winpr/cast.h>
27
28#include <freerdp/config.h>
29
30#include <freerdp/types.h>
31#include <freerdp/primitives.h>
32#include <freerdp/codec/color.h>
33#include "prim_internal.h"
34#include "prim_YUV.h"
35
36static inline pstatus_t general_LumaToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
37 const UINT32 srcStep[3],
38 BYTE* WINPR_RESTRICT pDstRaw[3],
39 const UINT32 dstStep[3],
40 const RECTANGLE_16* WINPR_RESTRICT roi)
41{
42 const UINT32 nWidth = roi->right - roi->left;
43 const UINT32 nHeight = roi->bottom - roi->top;
44 const UINT32 halfWidth = (nWidth + 1) / 2;
45 const UINT32 halfHeight = (nHeight + 1) / 2;
46 const UINT32 oddY = 1;
47 const UINT32 evenY = 0;
48 const UINT32 oddX = 1;
49 const UINT32 evenX = 0;
50 const BYTE* pSrc[3] = { pSrcRaw[0] + 1ULL * roi->top * srcStep[0] + roi->left,
51 pSrcRaw[1] + 1ULL * roi->top / 2 * srcStep[1] + roi->left / 2,
52 pSrcRaw[2] + 1ULL * roi->top / 2 * srcStep[2] + roi->left / 2 };
53 BYTE* pDst[3] = { pDstRaw[0] + 1ULL * roi->top * dstStep[0] + roi->left,
54 pDstRaw[1] + 1ULL * roi->top * dstStep[1] + roi->left,
55 pDstRaw[2] + 1ULL * roi->top * dstStep[2] + roi->left };
56
57 /* Y data is already here... */
58 /* B1 */
59 for (size_t y = 0; y < nHeight; y++)
60 {
61 const BYTE* Ym = pSrc[0] + y * srcStep[0];
62 BYTE* pY = pDst[0] + dstStep[0] * y;
63 memcpy(pY, Ym, nWidth);
64 }
65
66 /* The first half of U, V are already here part of this frame. */
67 /* B2 and B3 */
68 for (UINT32 y = 0; y < halfHeight; y++)
69 {
70 const UINT32 val2y = (2UL * y + evenY);
71 const UINT32 val2y1 = val2y + oddY;
72 const BYTE* Um = pSrc[1] + 1ULL * y * srcStep[1];
73 const BYTE* Vm = pSrc[2] + 1ULL * y * srcStep[2];
74 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;
75 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;
76 BYTE* pU1 = pDst[1] + 1ULL * dstStep[1] * val2y1;
77 BYTE* pV1 = pDst[2] + 1ULL * dstStep[2] * val2y1;
78
79 for (UINT32 x = 0; x < halfWidth; x++)
80 {
81 const UINT32 val2x = 2UL * x + evenX;
82 const UINT32 val2x1 = val2x + oddX;
83 pU[val2x] = Um[x];
84 pV[val2x] = Vm[x];
85 pU[val2x1] = Um[x];
86 pV[val2x1] = Vm[x];
87 pU1[val2x] = Um[x];
88 pV1[val2x] = Vm[x];
89 pU1[val2x1] = Um[x];
90 pV1[val2x1] = Vm[x];
91 }
92 }
93
94 return PRIMITIVES_SUCCESS;
95}
96
97static inline pstatus_t general_ChromaV1ToYUV444(const BYTE* WINPR_RESTRICT pSrcRaw[3],
98 const UINT32 srcStep[3],
99 BYTE* WINPR_RESTRICT pDstRaw[3],
100 const UINT32 dstStep[3],
101 const RECTANGLE_16* WINPR_RESTRICT roi)
102{
103 const UINT32 mod = 16;
104 UINT32 uY = 0;
105 UINT32 vY = 0;
106 const UINT32 nWidth = roi->right - roi->left;
107 const UINT32 nHeight = roi->bottom - roi->top;
108 const UINT32 halfWidth = (nWidth) / 2;
109 const UINT32 halfHeight = (nHeight) / 2;
110 const UINT32 oddY = 1;
111 const UINT32 evenY = 0;
112 const UINT32 oddX = 1;
113 /* The auxiliary frame is aligned to multiples of 16x16.
114 * We need the padded height for B4 and B5 conversion. */
115 const UINT32 padHeigth = nHeight + 16 - nHeight % 16;
116 const BYTE* pSrc[3] = { pSrcRaw[0] + 1ULL * roi->top * srcStep[0] + roi->left,
117 pSrcRaw[1] + 1ULL * roi->top / 2 * srcStep[1] + roi->left / 2,
118 pSrcRaw[2] + 1ULL * roi->top / 2 * srcStep[2] + roi->left / 2 };
119 BYTE* pDst[3] = { pDstRaw[0] + 1ULL * roi->top * dstStep[0] + roi->left,
120 pDstRaw[1] + 1ULL * roi->top * dstStep[1] + roi->left,
121 pDstRaw[2] + 1ULL * roi->top * dstStep[2] + roi->left };
122
123 /* The second half of U and V is a bit more tricky... */
124 /* B4 and B5 */
125 for (size_t y = 0; y < padHeigth; y++)
126 {
127 const BYTE* Ya = pSrc[0] + y * srcStep[0];
128 BYTE* pX = NULL;
129
130 if ((y) % mod < (mod + 1) / 2)
131 {
132 const size_t pos = (2 * uY++ + oddY);
133
134 if (pos >= nHeight)
135 continue;
136
137 pX = pDst[1] + dstStep[1] * pos;
138 }
139 else
140 {
141 const size_t pos = (2 * vY++ + oddY);
142
143 if (pos >= nHeight)
144 continue;
145
146 pX = pDst[2] + dstStep[2] * pos;
147 }
148
149 memcpy(pX, Ya, nWidth);
150 }
151
152 /* B6 and B7 */
153 for (UINT32 y = 0; y < halfHeight; y++)
154 {
155 const UINT32 val2y = (y * 2UL + evenY);
156 const BYTE* Ua = pSrc[1] + 1ULL * y * srcStep[1];
157 const BYTE* Va = pSrc[2] + 1ULL * y * srcStep[2];
158 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;
159 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;
160
161 for (UINT32 x = 0; x < halfWidth; x++)
162 {
163 const UINT32 val2x1 = (x * 2 + oddX);
164 pU[val2x1] = Ua[x];
165 pV[val2x1] = Va[x];
166 }
167 }
168
169 return PRIMITIVES_SUCCESS;
170}
171
172static inline pstatus_t general_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3],
173 const UINT32 srcStep[3], UINT32 nTotalWidth,
174 WINPR_ATTR_UNUSED UINT32 nTotalHeight,
175 BYTE* WINPR_RESTRICT pDst[3],
176 const UINT32 dstStep[3],
177 const RECTANGLE_16* WINPR_RESTRICT roi)
178{
179 const UINT32 nWidth = roi->right - roi->left;
180 const UINT32 nHeight = roi->bottom - roi->top;
181 const UINT32 halfWidth = (nWidth + 1) / 2;
182 const UINT32 halfHeight = (nHeight + 1) / 2;
183 const UINT32 quaterWidth = (nWidth + 3) / 4;
184
185 /* B4 and B5: odd UV values for width/2, height */
186 for (UINT32 y = 0; y < nHeight; y++)
187 {
188 const UINT32 yTop = y + roi->top;
189 const BYTE* pYaU = pSrc[0] + 1ULL * srcStep[0] * yTop + roi->left / 2;
190 const BYTE* pYaV = pYaU + nTotalWidth / 2;
191 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * yTop + roi->left;
192 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * yTop + roi->left;
193
194 for (UINT32 x = 0; x < halfWidth; x++)
195 {
196 const UINT32 odd = 2UL * x + 1UL;
197 pU[odd] = *pYaU++;
198 pV[odd] = *pYaV++;
199 }
200 }
201
202 /* B6 - B9 */
203 for (size_t y = 0; y < halfHeight; y++)
204 {
205 const BYTE* pUaU = pSrc[1] + srcStep[1] * (y + roi->top / 2) + roi->left / 4;
206 const BYTE* pUaV = pUaU + nTotalWidth / 4;
207 const BYTE* pVaU = pSrc[2] + srcStep[2] * (y + roi->top / 2) + roi->left / 4;
208 const BYTE* pVaV = pVaU + nTotalWidth / 4;
209 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * (2ULL * y + 1 + roi->top) + roi->left;
210 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * (2ULL * y + 1 + roi->top) + roi->left;
211
212 for (size_t x = 0; x < quaterWidth; x++)
213 {
214 pU[4 * x + 0] = *pUaU++;
215 pV[4 * x + 0] = *pUaV++;
216 pU[4 * x + 2] = *pVaU++;
217 pV[4 * x + 2] = *pVaV++;
218 }
219 }
220
221 return PRIMITIVES_SUCCESS;
222}
223
224static pstatus_t general_YUV420CombineToYUV444(avc444_frame_type type,
225 const BYTE* WINPR_RESTRICT pSrc[3],
226 const UINT32 srcStep[3], UINT32 nWidth,
227 UINT32 nHeight, BYTE* WINPR_RESTRICT pDst[3],
228 const UINT32 dstStep[3],
229 const RECTANGLE_16* WINPR_RESTRICT roi)
230{
231 if (!pSrc || !pSrc[0] || !pSrc[1] || !pSrc[2])
232 return -1;
233
234 if (!pDst || !pDst[0] || !pDst[1] || !pDst[2])
235 return -1;
236
237 if (!roi)
238 return -1;
239
240 switch (type)
241 {
242 case AVC444_LUMA:
243 return general_LumaToYUV444(pSrc, srcStep, pDst, dstStep, roi);
244
245 case AVC444_CHROMAv1:
246 return general_ChromaV1ToYUV444(pSrc, srcStep, pDst, dstStep, roi);
247
248 case AVC444_CHROMAv2:
249 return general_ChromaV2ToYUV444(pSrc, srcStep, nWidth, nHeight, pDst, dstStep, roi);
250
251 default:
252 return -1;
253 }
254}
255
256static pstatus_t
257general_YUV444SplitToYUV420(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
258 BYTE* WINPR_RESTRICT pMainDst[3], const UINT32 dstMainStep[3],
259 BYTE* WINPR_RESTRICT pAuxDst[3], const UINT32 dstAuxStep[3],
260 const prim_size_t* WINPR_RESTRICT roi)
261{
262 UINT32 uY = 0;
263 UINT32 vY = 0;
264
265 /* The auxiliary frame is aligned to multiples of 16x16.
266 * We need the padded height for B4 and B5 conversion. */
267 const UINT32 padHeigth = roi->height + 16 - roi->height % 16;
268 const UINT32 halfWidth = (roi->width + 1) / 2;
269 const UINT32 halfHeight = (roi->height + 1) / 2;
270
271 /* B1 */
272 for (size_t y = 0; y < roi->height; y++)
273 {
274 const BYTE* pSrcY = pSrc[0] + y * srcStep[0];
275 BYTE* pY = pMainDst[0] + y * dstMainStep[0];
276 memcpy(pY, pSrcY, roi->width);
277 }
278
279 /* B2 and B3 */
280 for (size_t y = 0; y < halfHeight; y++)
281 {
282 const BYTE* pSrcU = pSrc[1] + 2ULL * y * srcStep[1];
283 const BYTE* pSrcV = pSrc[2] + 2ULL * y * srcStep[2];
284 BYTE* pU = pMainDst[1] + y * dstMainStep[1];
285 BYTE* pV = pMainDst[2] + y * dstMainStep[2];
286
287 for (size_t x = 0; x < halfWidth; x++)
288 {
289 pU[x] = pSrcV[2 * x];
290 pV[x] = pSrcU[2 * x];
291 }
292 }
293
294 /* B4 and B5 */
295 for (size_t y = 0; y < padHeigth; y++)
296 {
297 BYTE* pY = pAuxDst[0] + y * dstAuxStep[0];
298
299 if (y % 16 < 8)
300 {
301 const size_t pos = (2 * uY++ + 1);
302 const BYTE* pSrcU = pSrc[1] + pos * srcStep[1];
303
304 if (pos >= roi->height)
305 continue;
306
307 memcpy(pY, pSrcU, roi->width);
308 }
309 else
310 {
311 const size_t pos = (2 * vY++ + 1);
312 const BYTE* pSrcV = pSrc[2] + pos * srcStep[2];
313
314 if (pos >= roi->height)
315 continue;
316
317 memcpy(pY, pSrcV, roi->width);
318 }
319 }
320
321 /* B6 and B7 */
322 for (size_t y = 0; y < halfHeight; y++)
323 {
324 const BYTE* pSrcU = pSrc[1] + 2 * y * srcStep[1];
325 const BYTE* pSrcV = pSrc[2] + 2 * y * srcStep[2];
326 BYTE* pU = pAuxDst[1] + y * dstAuxStep[1];
327 BYTE* pV = pAuxDst[2] + y * dstAuxStep[2];
328
329 for (size_t x = 0; x < halfWidth; x++)
330 {
331 pU[x] = pSrcU[2 * x + 1];
332 pV[x] = pSrcV[2 * x + 1];
333 }
334 }
335
336 return PRIMITIVES_SUCCESS;
337}
338
339static inline void general_YUV444ToRGB_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
340 const BYTE* WINPR_RESTRICT pY[2],
341 const BYTE* WINPR_RESTRICT pU[2],
342 const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
343{
344 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
345
346 WINPR_ASSERT(nWidth % 2 == 0);
347 for (size_t x = 0; x < nWidth; x += 2)
348 {
349 for (size_t i = 0; i < 2; i++)
350 {
351 for (size_t j = 0; j < 2; j++)
352 {
353 const BYTE y = pY[i][x + j];
354 INT32 u = pU[i][x + j];
355 INT32 v = pV[i][x + j];
356 if ((i == 0) && (j == 0))
357 {
358 const INT32 subU = (INT32)pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
359 const INT32 avgU = ((4 * u) - subU);
360 u = CONDITIONAL_CLIP(avgU, WINPR_ASSERTING_INT_CAST(BYTE, u));
361
362 const INT32 subV = (INT32)pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
363 const INT32 avgV = ((4 * v) - subV);
364 v = CONDITIONAL_CLIP(avgV, WINPR_ASSERTING_INT_CAST(BYTE, v));
365 }
366 pRGB[i] = writeYUVPixel(pRGB[i], DstFormat, y, u, v, writePixel);
367 }
368 }
369 }
370}
371
372static inline void general_YUV444ToRGB_SINGLE_ROW(BYTE* WINPR_RESTRICT pRGB, UINT32 DstFormat,
373 const BYTE* WINPR_RESTRICT pY,
374 const BYTE* WINPR_RESTRICT pU,
375 const BYTE* WINPR_RESTRICT pV, size_t nWidth)
376{
377 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
378
379 WINPR_ASSERT(nWidth % 2 == 0);
380 for (size_t x = 0; x < nWidth; x += 2)
381 {
382 for (size_t j = 0; j < 2; j++)
383 {
384 const BYTE y = pY[x + j];
385 const BYTE u = pU[x + j];
386 const BYTE v = pV[x + j];
387 pRGB = writeYUVPixel(pRGB, DstFormat, y, u, v, writePixel);
388 }
389 }
390}
391
392static inline pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* WINPR_RESTRICT pSrc[3],
393 const UINT32 srcStep[3],
394 BYTE* WINPR_RESTRICT pDst,
395 UINT32 dstStep, UINT32 DstFormat,
396 const prim_size_t* WINPR_RESTRICT roi)
397{
398 WINPR_ASSERT(pSrc);
399 WINPR_ASSERT(pDst);
400 WINPR_ASSERT(roi);
401
402 const UINT32 nWidth = roi->width;
403 const UINT32 nHeight = roi->height;
404
405 size_t y = 0;
406 for (; y < nHeight - nHeight % 2; y += 2)
407 {
408 const BYTE* WINPR_RESTRICT pY[2] = { pSrc[0] + y * srcStep[0],
409 pSrc[0] + (y + 1) * srcStep[0] };
410 const BYTE* WINPR_RESTRICT pU[2] = { pSrc[1] + y * srcStep[1],
411 pSrc[1] + (y + 1) * srcStep[1] };
412 const BYTE* WINPR_RESTRICT pV[2] = { pSrc[2] + y * srcStep[2],
413 pSrc[2] + (y + 1) * srcStep[2] };
414 BYTE* WINPR_RESTRICT pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
415
416 general_YUV444ToRGB_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
417 }
418 for (; y < nHeight; y++)
419 {
420 const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
421 const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
422 const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
423 BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
424
425 general_YUV444ToRGB_SINGLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
426 }
427
428 return PRIMITIVES_SUCCESS;
429}
430
431static inline void general_YUV444ToBGRX_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
432 const BYTE* WINPR_RESTRICT pY[2],
433 const BYTE* WINPR_RESTRICT pU[2],
434 const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
435{
436 WINPR_ASSERT(nWidth % 2 == 0);
437 for (size_t x = 0; x < nWidth; x += 2)
438 {
439 const INT32 subU = pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
440 const INT32 avgU = ((4 * pU[0][x]) - subU);
441 const BYTE useU = CONDITIONAL_CLIP(avgU, pU[0][x]);
442 const INT32 subV = pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
443 const INT32 avgV = ((4 * pV[0][x]) - subV);
444 const BYTE useV = CONDITIONAL_CLIP(avgV, pV[0][x]);
445
446 const BYTE U[2][2] = { { useU, pU[0][x + 1] }, { pU[1][x], pU[1][x + 1] } };
447 const BYTE V[2][2] = { { useV, pV[0][x + 1] }, { pV[1][x], pV[1][x + 1] } };
448
449 for (size_t i = 0; i < 2; i++)
450 {
451 for (size_t j = 0; j < 2; j++)
452 {
453 const BYTE y = pY[i][x + j];
454 const BYTE u = U[i][j];
455 const BYTE v = V[i][j];
456 pRGB[i] = writeYUVPixel(pRGB[i], DstFormat, y, u, v, writePixelBGRX);
457 }
458 }
459 }
460}
461
462static inline void general_YUV444ToBGRX_SINGLE_ROW(BYTE* WINPR_RESTRICT pRGB, UINT32 DstFormat,
463 const BYTE* WINPR_RESTRICT pY,
464 const BYTE* WINPR_RESTRICT pU,
465 const BYTE* WINPR_RESTRICT pV, size_t nWidth)
466{
467 WINPR_ASSERT(nWidth % 2 == 0);
468 for (size_t x = 0; x < nWidth; x += 2)
469 {
470 for (size_t j = 0; j < 2; j++)
471 {
472 const BYTE Y = pY[x + j];
473 const BYTE U = pU[x + j];
474 const BYTE V = pV[x + j];
475 pRGB = writeYUVPixel(pRGB, DstFormat, Y, U, V, writePixelBGRX);
476 }
477 }
478}
479
480static inline pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc[3],
481 const UINT32 srcStep[3],
482 BYTE* WINPR_RESTRICT pDst,
483 UINT32 dstStep, UINT32 DstFormat,
484 const prim_size_t* WINPR_RESTRICT roi)
485{
486 WINPR_ASSERT(pSrc);
487 WINPR_ASSERT(pDst);
488 WINPR_ASSERT(roi);
489
490 const UINT32 nWidth = roi->width;
491 const UINT32 nHeight = roi->height;
492
493 size_t y = 0;
494 for (; y < nHeight - nHeight % 2; y += 2)
495 {
496 const BYTE* pY[2] = { pSrc[0] + y * srcStep[0], pSrc[0] + (y + 1) * srcStep[0] };
497 const BYTE* pU[2] = { pSrc[1] + y * srcStep[1], pSrc[1] + (y + 1) * srcStep[1] };
498 const BYTE* pV[2] = { pSrc[2] + y * srcStep[2], pSrc[2] + (y + 1) * srcStep[2] };
499 BYTE* pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
500
501 general_YUV444ToBGRX_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
502 }
503
504 for (; y < nHeight; y++)
505 {
506 const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
507 const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
508 const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
509 BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
510
511 general_YUV444ToBGRX_SINGLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
512 }
513 return PRIMITIVES_SUCCESS;
514}
515
516static pstatus_t general_YUV444ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
517 const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
518 UINT32 dstStep, UINT32 DstFormat,
519 const prim_size_t* WINPR_RESTRICT roi)
520{
521 switch (DstFormat)
522 {
523 case PIXEL_FORMAT_BGRA32:
524 case PIXEL_FORMAT_BGRX32:
525 return general_YUV444ToRGB_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, DstFormat, roi);
526
527 default:
528 return general_YUV444ToRGB_8u_P3AC4R_general(pSrc, srcStep, pDst, dstStep, DstFormat,
529 roi);
530 }
531}
537static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
538 const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
539 UINT32 dstStep, UINT32 DstFormat,
540 const prim_size_t* WINPR_RESTRICT roi)
541{
542 WINPR_ASSERT(roi);
543 const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
544 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
545 UINT32 lastCol = roi->width & 0x01;
546 UINT32 lastRow = roi->height & 0x01;
547 const UINT32 nWidth = (roi->width + 1) & (uint32_t)~0x0001;
548 const UINT32 nHeight = (roi->height + 1) & (uint32_t)~0x0001;
549 const UINT32 halfWidth = nWidth / 2;
550 const UINT32 halfHeight = nHeight / 2;
551
552 for (UINT32 y = 0; y < halfHeight; y++)
553 {
554 const BYTE* pY = &pSrc[0][2ULL * srcStep[0] * y];
555
556 if (y + 1 == halfHeight)
557 lastRow <<= 1;
558
559 {
560 const BYTE* pU = &pSrc[1][1ULL * srcStep[1] * y];
561 const BYTE* pV = &pSrc[2][1ULL * srcStep[2] * y];
562 BYTE* pRGBeven = &pDst[2ULL * y * dstStep];
563 for (UINT32 x = 0; x < halfWidth;)
564 {
565 if (++x == halfWidth)
566 lastCol <<= 1;
567
568 const BYTE U = *pU++;
569 const BYTE V = *pV++;
570 /* 1st pixel */
571 {
572 const BYTE Y = *pY++;
573 pRGBeven = writeYUVPixel(pRGBeven, DstFormat, Y, U, V, writePixel);
574 }
575
576 /* 2nd pixel */
577 if (!(lastCol & 0x02))
578 {
579 const BYTE Y1 = *pY++;
580 pRGBeven = writeYUVPixel(pRGBeven, DstFormat, Y1, U, V, writePixel);
581 }
582 else
583 {
584 pY++;
585 pRGBeven += formatSize;
586 lastCol >>= 1;
587 }
588 }
589 }
590
591 if (lastRow & 0x02)
592 break;
593
594 {
595 const BYTE* pU = &pSrc[1][1ULL * srcStep[1] * y];
596 const BYTE* pV = &pSrc[2][1ULL * srcStep[2] * y];
597 BYTE* pRGBodd = &pDst[(2ULL * y + 1ULL) * dstStep];
598
599 for (UINT32 x = 0; x < halfWidth;)
600 {
601 if (++x == halfWidth)
602 lastCol <<= 1;
603
604 const BYTE U = *pU++;
605 const BYTE V = *pV++;
606 /* 3rd pixel */
607 {
608 const BYTE Y = *pY++;
609 pRGBodd = writeYUVPixel(pRGBodd, DstFormat, Y, U, V, writePixel);
610 }
611
612 /* 4th pixel */
613 if (!(lastCol & 0x02))
614 {
615 const BYTE Y1 = *pY++;
616 pRGBodd = writeYUVPixel(pRGBodd, DstFormat, Y1, U, V, writePixel);
617 }
618 else
619 {
620 pY++;
621 pRGBodd += formatSize;
622 lastCol >>= 1;
623 }
624 }
625 }
626 }
627
628 return PRIMITIVES_SUCCESS;
629}
630
631static inline void BGRX_fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2],
632 BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
633 BYTE* WINPR_RESTRICT pV[2])
634{
635 WINPR_ASSERT(pRGB);
636 WINPR_ASSERT(pY);
637 WINPR_ASSERT(pU);
638 WINPR_ASSERT(pV);
639
640 const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
641 const UINT32 bpp = 4;
642
643 for (size_t i = 0; i < 2; i++)
644 {
645 for (size_t j = 0; j < 2; j++)
646 {
647 BYTE B = 0;
648 BYTE G = 0;
649 BYTE R = 0;
650 const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
651 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
652 pY[i][offset + j] = RGB2Y(R, G, B);
653 pU[i][offset + j] = RGB2U(R, G, B);
654 pV[i][offset + j] = RGB2V(R, G, B);
655 }
656 }
657
658 /* Apply chroma filter */
659 const INT32 avgU = (pU[0][offset] + pU[0][offset + 1] + pU[1][offset] + pU[1][offset + 1]) / 4;
660 pU[0][offset] = CONDITIONAL_CLIP(avgU, pU[0][offset]);
661 const INT32 avgV = (pV[0][offset] + pV[0][offset + 1] + pV[1][offset] + pV[1][offset + 1]) / 4;
662 pV[0][offset] = CONDITIONAL_CLIP(avgV, pV[0][offset]);
663}
664
665static inline void BGRX_fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB,
666 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
667 BYTE* WINPR_RESTRICT pV)
668{
669 WINPR_ASSERT(pRGB);
670 WINPR_ASSERT(pY);
671 WINPR_ASSERT(pU);
672 WINPR_ASSERT(pV);
673
674 const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
675 const UINT32 bpp = 4;
676
677 for (size_t j = 0; j < 2; j++)
678 {
679 BYTE B = 0;
680 BYTE G = 0;
681 BYTE R = 0;
682 const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
683 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
684 pY[offset + j] = RGB2Y(R, G, B);
685 pU[offset + j] = RGB2U(R, G, B);
686 pV[offset + j] = RGB2V(R, G, B);
687 }
688}
689
690static inline void general_BGRXToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
691 BYTE* WINPR_RESTRICT pY[2],
692 BYTE* WINPR_RESTRICT pU[2],
693 BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
694{
695
696 WINPR_ASSERT((nWidth % 2) == 0);
697 for (size_t x = 0; x < nWidth; x += 2)
698 {
699 BGRX_fillYUV(x, pRGB, pY, pU, pV);
700 }
701}
702
703static inline void general_BGRXToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB,
704 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
705 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
706{
707
708 WINPR_ASSERT((nWidth % 2) == 0);
709 for (size_t x = 0; x < nWidth; x += 2)
710 {
711 BGRX_fillYUV_single(x, pRGB, pY, pU, pV);
712 }
713}
714
715static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc,
716 const UINT32 srcStep,
717 BYTE* WINPR_RESTRICT pDst[3],
718 const UINT32 dstStep[3],
719 const prim_size_t* WINPR_RESTRICT roi)
720{
721 const UINT32 nWidth = roi->width;
722 const UINT32 nHeight = roi->height;
723
724 size_t y = 0;
725 for (; y < nHeight - nHeight % 2; y += 2)
726 {
727 const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
728 BYTE* pY[] = { pDst[0] + y * dstStep[0], pDst[0] + (y + 1) * dstStep[0] };
729 BYTE* pU[] = { pDst[1] + y * dstStep[1], pDst[1] + (y + 1) * dstStep[1] };
730 BYTE* pV[] = { pDst[2] + y * dstStep[2], pDst[2] + (y + 1) * dstStep[2] };
731
732 general_BGRXToYUV444_DOUBLE_ROW(pRGB, pY, pU, pV, nWidth);
733 }
734
735 for (; y < nHeight; y++)
736 {
737 const BYTE* pRGB = pSrc + y * srcStep;
738 BYTE* pY = pDst[0] + y * dstStep[0];
739 BYTE* pU = pDst[1] + y * dstStep[1];
740 BYTE* pV = pDst[2] + y * dstStep[2];
741
742 general_BGRXToYUV444_SINGLE_ROW(pRGB, pY, pU, pV, nWidth);
743 }
744
745 return PRIMITIVES_SUCCESS;
746}
747
748static inline void fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2], UINT32 SrcFormat,
749 BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
750 BYTE* WINPR_RESTRICT pV[2])
751{
752 WINPR_ASSERT(pRGB);
753 WINPR_ASSERT(pY);
754 WINPR_ASSERT(pU);
755 WINPR_ASSERT(pV);
756 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
757
758 INT32 avgU = 0;
759 INT32 avgV = 0;
760 for (size_t i = 0; i < 2; i++)
761 {
762 for (size_t j = 0; j < 2; j++)
763 {
764 BYTE B = 0;
765 BYTE G = 0;
766 BYTE R = 0;
767 const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
768 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
769 const BYTE y = RGB2Y(R, G, B);
770 const BYTE u = RGB2U(R, G, B);
771 const BYTE v = RGB2V(R, G, B);
772 avgU += u;
773 avgV += v;
774 pY[i][offset + j] = y;
775 pU[i][offset + j] = u;
776 pV[i][offset + j] = v;
777 }
778 }
779
780 /* Apply chroma filter */
781 avgU /= 4;
782 pU[0][offset] = CLIP(avgU);
783
784 avgV /= 4;
785 pV[0][offset] = CLIP(avgV);
786}
787
788static inline void fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
789 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
790 BYTE* WINPR_RESTRICT pV)
791{
792 WINPR_ASSERT(pRGB);
793 WINPR_ASSERT(pY);
794 WINPR_ASSERT(pU);
795 WINPR_ASSERT(pV);
796 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
797
798 for (size_t j = 0; j < 2; j++)
799 {
800 BYTE B = 0;
801 BYTE G = 0;
802 BYTE R = 0;
803 const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
804 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);
805 const BYTE y = RGB2Y(R, G, B);
806 const BYTE u = RGB2U(R, G, B);
807 const BYTE v = RGB2V(R, G, B);
808 pY[offset + j] = y;
809 pU[offset + j] = u;
810 pV[offset + j] = v;
811 }
812}
813
814static inline void general_RGBToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
815 UINT32 SrcFormat, BYTE* WINPR_RESTRICT pY[2],
816 BYTE* WINPR_RESTRICT pU[2],
817 BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
818{
819
820 WINPR_ASSERT((nWidth % 2) == 0);
821 for (size_t x = 0; x < nWidth; x += 2)
822 {
823 fillYUV(x, pRGB, SrcFormat, pY, pU, pV);
824 }
825}
826
827static inline void general_RGBToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
828 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
829 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
830{
831
832 WINPR_ASSERT((nWidth % 2) == 0);
833 for (size_t x = 0; x < nWidth; x += 2)
834 {
835 fillYUV_single(x, pRGB, SrcFormat, pY, pU, pV);
836 }
837}
838
839static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_RGB(const BYTE* WINPR_RESTRICT pSrc,
840 UINT32 SrcFormat, const UINT32 srcStep,
841 BYTE* WINPR_RESTRICT pDst[3],
842 const UINT32 dstStep[3],
843 const prim_size_t* WINPR_RESTRICT roi)
844{
845 const UINT32 nWidth = roi->width;
846 const UINT32 nHeight = roi->height;
847
848 size_t y = 0;
849 for (; y < nHeight - nHeight % 2; y += 2)
850 {
851 const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
852 BYTE* pY[] = { &pDst[0][y * dstStep[0]], &pDst[0][(y + 1) * dstStep[0]] };
853 BYTE* pU[] = { &pDst[1][y * dstStep[1]], &pDst[1][(y + 1) * dstStep[1]] };
854 BYTE* pV[] = { &pDst[2][y * dstStep[2]], &pDst[2][(y + 1) * dstStep[2]] };
855
856 general_RGBToYUV444_DOUBLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
857 }
858 for (; y < nHeight; y++)
859 {
860 const BYTE* pRGB = pSrc + y * srcStep;
861 BYTE* pY = &pDst[0][y * dstStep[0]];
862 BYTE* pU = &pDst[1][y * dstStep[1]];
863 BYTE* pV = &pDst[2][y * dstStep[2]];
864
865 general_RGBToYUV444_SINGLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
866 }
867
868 return PRIMITIVES_SUCCESS;
869}
870
871static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
872 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
873 const UINT32 dstStep[3],
874 const prim_size_t* WINPR_RESTRICT roi)
875{
876 switch (SrcFormat)
877 {
878 case PIXEL_FORMAT_BGRA32:
879 case PIXEL_FORMAT_BGRX32:
880 return general_RGBToYUV444_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, roi);
881 default:
882 return general_RGBToYUV444_8u_P3AC4R_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
883 }
884}
885
886static inline pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
887 BYTE* WINPR_RESTRICT pDst[3],
888 const UINT32 dstStep[3],
889 const prim_size_t* WINPR_RESTRICT roi)
890{
891 size_t x1 = 0;
892 size_t x2 = 4;
893 size_t x3 = srcStep;
894 size_t x4 = srcStep + 4;
895 size_t y1 = 0;
896 size_t y2 = 1;
897 size_t y3 = dstStep[0];
898 size_t y4 = dstStep[0] + 1;
899 UINT32 max_x = roi->width - 1;
900
901 size_t y = 0;
902 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
903 {
904 const BYTE* src = pSrc + y * srcStep;
905 BYTE* ydst = pDst[0] + y * dstStep[0];
906 BYTE* udst = pDst[1] + i * dstStep[1];
907 BYTE* vdst = pDst[2] + i * dstStep[2];
908
909 for (size_t x = 0; x < roi->width; x += 2)
910 {
911 BYTE R = 0;
912 BYTE G = 0;
913 BYTE B = 0;
914 INT32 Ra = 0;
915 INT32 Ga = 0;
916 INT32 Ba = 0;
917 /* row 1, pixel 1 */
918 Ba = B = *(src + x1 + 0);
919 Ga = G = *(src + x1 + 1);
920 Ra = R = *(src + x1 + 2);
921 ydst[y1] = RGB2Y(R, G, B);
922
923 if (x < max_x)
924 {
925 /* row 1, pixel 2 */
926 Ba += B = *(src + x2 + 0);
927 Ga += G = *(src + x2 + 1);
928 Ra += R = *(src + x2 + 2);
929 ydst[y2] = RGB2Y(R, G, B);
930 }
931
932 /* row 2, pixel 1 */
933 Ba += B = *(src + x3 + 0);
934 Ga += G = *(src + x3 + 1);
935 Ra += R = *(src + x3 + 2);
936 ydst[y3] = RGB2Y(R, G, B);
937
938 if (x < max_x)
939 {
940 /* row 2, pixel 2 */
941 Ba += B = *(src + x4 + 0);
942 Ga += G = *(src + x4 + 1);
943 Ra += R = *(src + x4 + 2);
944 ydst[y4] = RGB2Y(R, G, B);
945 }
946
947 Ba >>= 2;
948 Ga >>= 2;
949 Ra >>= 2;
950 *udst++ = RGB2U(Ra, Ga, Ba);
951 *vdst++ = RGB2V(Ra, Ga, Ba);
952 ydst += 2;
953 src += 8;
954 }
955 }
956
957 for (; y < roi->height; y++)
958 {
959 const BYTE* src = pSrc + y * srcStep;
960 BYTE* ydst = pDst[0] + y * dstStep[0];
961 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
962 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
963
964 for (size_t x = 0; x < roi->width; x += 2)
965 {
966 BYTE R = 0;
967 BYTE G = 0;
968 BYTE B = 0;
969 INT32 Ra = 0;
970 INT32 Ga = 0;
971 INT32 Ba = 0;
972 /* row 1, pixel 1 */
973 Ba = B = *(src + x1 + 0);
974 Ga = G = *(src + x1 + 1);
975 Ra = R = *(src + x1 + 2);
976 ydst[y1] = RGB2Y(R, G, B);
977
978 if (x < max_x)
979 {
980 /* row 1, pixel 2 */
981 Ba += B = *(src + x2 + 0);
982 Ga += G = *(src + x2 + 1);
983 Ra += R = *(src + x2 + 2);
984 ydst[y2] = RGB2Y(R, G, B);
985 }
986
987 Ba >>= 2;
988 Ga >>= 2;
989 Ra >>= 2;
990 *udst++ = RGB2U(Ra, Ga, Ba);
991 *vdst++ = RGB2V(Ra, Ga, Ba);
992 ydst += 2;
993 src += 8;
994 }
995 }
996
997 return PRIMITIVES_SUCCESS;
998}
999
1000static inline pstatus_t general_RGBToYUV420_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1001 BYTE* WINPR_RESTRICT pDst[3],
1002 const UINT32 dstStep[3],
1003 const prim_size_t* WINPR_RESTRICT roi)
1004{
1005 size_t x1 = 0;
1006 size_t x2 = 4;
1007 size_t x3 = srcStep;
1008 size_t x4 = srcStep + 4;
1009 size_t y1 = 0;
1010 size_t y2 = 1;
1011 size_t y3 = dstStep[0];
1012 size_t y4 = dstStep[0] + 1;
1013 UINT32 max_x = roi->width - 1;
1014
1015 size_t y = 0;
1016 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1017 {
1018 const BYTE* src = pSrc + y * srcStep;
1019 BYTE* ydst = pDst[0] + y * dstStep[0];
1020 BYTE* udst = pDst[1] + i * dstStep[1];
1021 BYTE* vdst = pDst[2] + i * dstStep[2];
1022
1023 for (UINT32 x = 0; x < roi->width; x += 2)
1024 {
1025 BYTE R = *(src + x1 + 0);
1026 BYTE G = *(src + x1 + 1);
1027 BYTE B = *(src + x1 + 2);
1028 /* row 1, pixel 1 */
1029 INT32 Ra = R;
1030 INT32 Ga = G;
1031 INT32 Ba = B;
1032 ydst[y1] = RGB2Y(R, G, B);
1033
1034 if (x < max_x)
1035 {
1036 /* row 1, pixel 2 */
1037 R = *(src + x2 + 0);
1038 G = *(src + x2 + 1);
1039 B = *(src + x2 + 2);
1040 Ra += R;
1041 Ga += G;
1042 Ba += B;
1043 ydst[y2] = RGB2Y(R, G, B);
1044 }
1045
1046 /* row 2, pixel 1 */
1047 R = *(src + x3 + 0);
1048 G = *(src + x3 + 1);
1049 B = *(src + x3 + 2);
1050
1051 Ra += R;
1052 Ga += G;
1053 Ba += B;
1054 ydst[y3] = RGB2Y(R, G, B);
1055
1056 if (x < max_x)
1057 {
1058 /* row 2, pixel 2 */
1059 R = *(src + x4 + 0);
1060 G = *(src + x4 + 1);
1061 B = *(src + x4 + 2);
1062
1063 Ra += R;
1064 Ga += G;
1065 Ba += B;
1066 ydst[y4] = RGB2Y(R, G, B);
1067 }
1068
1069 Ba >>= 2;
1070 Ga >>= 2;
1071 Ra >>= 2;
1072 *udst++ = RGB2U(Ra, Ga, Ba);
1073 *vdst++ = RGB2V(Ra, Ga, Ba);
1074 ydst += 2;
1075 src += 8;
1076 }
1077 }
1078
1079 for (; y < roi->height; y++)
1080 {
1081 const BYTE* src = pSrc + y * srcStep;
1082 BYTE* ydst = pDst[0] + y * dstStep[0];
1083 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1084 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1085
1086 for (UINT32 x = 0; x < roi->width; x += 2)
1087 {
1088 BYTE R = *(src + x1 + 0);
1089 BYTE G = *(src + x1 + 1);
1090 BYTE B = *(src + x1 + 2);
1091 /* row 1, pixel 1 */
1092 INT32 Ra = R;
1093 INT32 Ga = G;
1094 INT32 Ba = B;
1095 ydst[y1] = RGB2Y(R, G, B);
1096
1097 if (x < max_x)
1098 {
1099 /* row 1, pixel 2 */
1100 R = *(src + x2 + 0);
1101 G = *(src + x2 + 1);
1102 B = *(src + x2 + 2);
1103 Ra += R;
1104 Ga += G;
1105 Ba += B;
1106 ydst[y2] = RGB2Y(R, G, B);
1107 }
1108
1109 Ba >>= 2;
1110 Ga >>= 2;
1111 Ra >>= 2;
1112 *udst++ = RGB2U(Ra, Ga, Ba);
1113 *vdst++ = RGB2V(Ra, Ga, Ba);
1114 ydst += 2;
1115 src += 8;
1116 }
1117 }
1118
1119 return PRIMITIVES_SUCCESS;
1120}
1121
1122static inline pstatus_t general_RGBToYUV420_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1123 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1124 const UINT32 dstStep[3],
1125 const prim_size_t* WINPR_RESTRICT roi)
1126{
1127 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1128 size_t x1 = 0;
1129 size_t x2 = bpp;
1130 size_t x3 = srcStep;
1131 size_t x4 = srcStep + bpp;
1132 size_t y1 = 0;
1133 size_t y2 = 1;
1134 size_t y3 = dstStep[0];
1135 size_t y4 = dstStep[0] + 1;
1136 UINT32 max_x = roi->width - 1;
1137
1138 size_t y = 0;
1139 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1140 {
1141 const BYTE* src = pSrc + y * srcStep;
1142 BYTE* ydst = pDst[0] + y * dstStep[0];
1143 BYTE* udst = pDst[1] + i * dstStep[1];
1144 BYTE* vdst = pDst[2] + i * dstStep[2];
1145
1146 for (size_t x = 0; x < roi->width; x += 2)
1147 {
1148 BYTE R = 0;
1149 BYTE G = 0;
1150 BYTE B = 0;
1151 INT32 Ra = 0;
1152 INT32 Ga = 0;
1153 INT32 Ba = 0;
1154 UINT32 color = 0;
1155 /* row 1, pixel 1 */
1156 color = FreeRDPReadColor(src + x1, srcFormat);
1157 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
1158 Ra = R;
1159 Ga = G;
1160 Ba = B;
1161 ydst[y1] = RGB2Y(R, G, B);
1162
1163 if (x < max_x)
1164 {
1165 /* row 1, pixel 2 */
1166 color = FreeRDPReadColor(src + x2, srcFormat);
1167 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
1168 Ra += R;
1169 Ga += G;
1170 Ba += B;
1171 ydst[y2] = RGB2Y(R, G, B);
1172 }
1173
1174 /* row 2, pixel 1 */
1175 color = FreeRDPReadColor(src + x3, srcFormat);
1176 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
1177 Ra += R;
1178 Ga += G;
1179 Ba += B;
1180 ydst[y3] = RGB2Y(R, G, B);
1181
1182 if (x < max_x)
1183 {
1184 /* row 2, pixel 2 */
1185 color = FreeRDPReadColor(src + x4, srcFormat);
1186 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
1187 Ra += R;
1188 Ga += G;
1189 Ba += B;
1190 ydst[y4] = RGB2Y(R, G, B);
1191 }
1192
1193 Ra >>= 2;
1194 Ga >>= 2;
1195 Ba >>= 2;
1196 *udst++ = RGB2U(Ra, Ga, Ba);
1197 *vdst++ = RGB2V(Ra, Ga, Ba);
1198 ydst += 2;
1199 src += 2ULL * bpp;
1200 }
1201 }
1202
1203 for (; y < roi->height; y++)
1204 {
1205 const BYTE* src = pSrc + y * srcStep;
1206 BYTE* ydst = pDst[0] + y * dstStep[0];
1207 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1208 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1209
1210 for (size_t x = 0; x < roi->width; x += 2)
1211 {
1212 BYTE R = 0;
1213 BYTE G = 0;
1214 BYTE B = 0;
1215 /* row 1, pixel 1 */
1216 UINT32 color = FreeRDPReadColor(src + x1, srcFormat);
1217 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
1218 INT32 Ra = R;
1219 INT32 Ga = G;
1220 INT32 Ba = B;
1221 ydst[y1] = RGB2Y(R, G, B);
1222
1223 if (x < max_x)
1224 {
1225 /* row 1, pixel 2 */
1226 color = FreeRDPReadColor(src + x2, srcFormat);
1227 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);
1228 Ra += R;
1229 Ga += G;
1230 Ba += B;
1231 ydst[y2] = RGB2Y(R, G, B);
1232 }
1233
1234 Ra >>= 2;
1235 Ga >>= 2;
1236 Ba >>= 2;
1237 *udst++ = RGB2U(Ra, Ga, Ba);
1238 *vdst++ = RGB2V(Ra, Ga, Ba);
1239 ydst += 2;
1240 src += 2ULL * bpp;
1241 }
1242 }
1243
1244 return PRIMITIVES_SUCCESS;
1245}
1246
1247static pstatus_t general_RGBToYUV420_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1248 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1249 const UINT32 dstStep[3],
1250 const prim_size_t* WINPR_RESTRICT roi)
1251{
1252 switch (srcFormat)
1253 {
1254 case PIXEL_FORMAT_BGRA32:
1255 case PIXEL_FORMAT_BGRX32:
1256 return general_RGBToYUV420_BGRX(pSrc, srcStep, pDst, dstStep, roi);
1257
1258 case PIXEL_FORMAT_RGBA32:
1259 case PIXEL_FORMAT_RGBX32:
1260 return general_RGBToYUV420_RGBX(pSrc, srcStep, pDst, dstStep, roi);
1261
1262 default:
1263 return general_RGBToYUV420_ANY(pSrc, srcFormat, srcStep, pDst, dstStep, roi);
1264 }
1265}
1266
1267static inline void int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
1268 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
1269 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1270 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1271 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1272{
1273 WINPR_ASSERT((width % 2) == 0);
1274 for (size_t x = offset; x < width; x += 2)
1275 {
1276 const BYTE* srcEven = &pSrcEven[4ULL * x];
1277 const BYTE* srcOdd = &pSrcOdd[4ULL * x];
1278 const BOOL lastX = (x + 1) >= width;
1279 BYTE Y1e = 0;
1280 BYTE Y2e = 0;
1281 BYTE U1e = 0;
1282 BYTE V1e = 0;
1283 BYTE U2e = 0;
1284 BYTE V2e = 0;
1285 BYTE Y1o = 0;
1286 BYTE Y2o = 0;
1287 BYTE U1o = 0;
1288 BYTE V1o = 0;
1289 BYTE U2o = 0;
1290 BYTE V2o = 0;
1291 /* Read 4 pixels, 2 from even, 2 from odd lines */
1292 {
1293 const BYTE b = *srcEven++;
1294 const BYTE g = *srcEven++;
1295 const BYTE r = *srcEven++;
1296 srcEven++;
1297 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1298 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1299 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1300 }
1301
1302 if (!lastX)
1303 {
1304 const BYTE b = *srcEven++;
1305 const BYTE g = *srcEven++;
1306 const BYTE r = *srcEven++;
1307 srcEven++;
1308 Y2e = RGB2Y(r, g, b);
1309 U2e = RGB2U(r, g, b);
1310 V2e = RGB2V(r, g, b);
1311 }
1312
1313 if (b1Odd)
1314 {
1315 const BYTE b = *srcOdd++;
1316 const BYTE g = *srcOdd++;
1317 const BYTE r = *srcOdd++;
1318 srcOdd++;
1319 Y1o = Y2o = RGB2Y(r, g, b);
1320 U1o = U2o = RGB2U(r, g, b);
1321 V1o = V2o = RGB2V(r, g, b);
1322 }
1323
1324 if (b1Odd && !lastX)
1325 {
1326 const BYTE b = *srcOdd++;
1327 const BYTE g = *srcOdd++;
1328 const BYTE r = *srcOdd++;
1329 srcOdd++;
1330 Y2o = RGB2Y(r, g, b);
1331 U2o = RGB2U(r, g, b);
1332 V2o = RGB2V(r, g, b);
1333 }
1334
1335 /* We have 4 Y pixels, so store them. */
1336 *b1Even++ = Y1e;
1337 *b1Even++ = Y2e;
1338
1339 if (b1Odd)
1340 {
1341 *b1Odd++ = Y1o;
1342 *b1Odd++ = Y2o;
1343 }
1344
1345 /* 2x 2y pixel in luma UV plane use averaging
1346 */
1347 {
1348 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1349 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1350 *b2++ = Uavg;
1351 *b3++ = Vavg;
1352 }
1353
1354 /* UV from 2x, 2y+1 */
1355 if (b1Odd)
1356 {
1357 *b4++ = U1o;
1358 *b5++ = V1o;
1359
1360 if (!lastX)
1361 {
1362 *b4++ = U2o;
1363 *b5++ = V2o;
1364 }
1365 }
1366
1367 /* UV from 2x+1, 2y */
1368 if (!lastX)
1369 {
1370 *b6++ = U2e;
1371 *b7++ = V2e;
1372 }
1373 }
1374}
1375
1376void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(size_t offset, const BYTE* WINPR_RESTRICT pSrcEven,
1377 const BYTE* WINPR_RESTRICT pSrcOdd,
1378 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd,
1379 BYTE* WINPR_RESTRICT b2, BYTE* WINPR_RESTRICT b3,
1380 BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1381 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7,
1382 UINT32 width)
1383{
1384 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(offset, pSrcEven, pSrcOdd, b1Even, b1Odd, b2, b3, b4,
1385 b5, b6, b7, width);
1386}
1387
1388static inline pstatus_t general_RGBToAVC444YUV_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1389 BYTE* WINPR_RESTRICT pDst1[3],
1390 const UINT32 dst1Step[3],
1391 BYTE* WINPR_RESTRICT pDst2[3],
1392 const UINT32 dst2Step[3],
1393 const prim_size_t* WINPR_RESTRICT roi)
1394{
1399 size_t y = 0;
1400 for (; y < roi->height - roi->height % 2; y += 2)
1401 {
1402 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1403 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1404 const size_t i = y >> 1;
1405 const size_t n = (i & (uint32_t)~7) + i;
1406 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1407 BYTE* b1Odd = (b1Even + dst1Step[0]);
1408 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1409 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1410 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1411 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1412 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1413 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1414 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4,
1415 b5, b6, b7, roi->width);
1416 }
1417 for (; y < roi->height; y++)
1418 {
1419 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1420 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1421 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1422 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1423 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1424 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1425 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, NULL, b1Even, NULL, b2, b3, NULL,
1426 NULL, b6, b7, roi->width);
1427 }
1428
1429 return PRIMITIVES_SUCCESS;
1430}
1431
1432static inline void general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(
1433 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
1434 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1435 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1436 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1437{
1438 WINPR_ASSERT((width % 2) == 0);
1439 for (UINT32 x = 0; x < width; x += 2)
1440 {
1441 const BOOL lastX = (x + 1) >= width;
1442 BYTE Y1e = 0;
1443 BYTE Y2e = 0;
1444 BYTE U1e = 0;
1445 BYTE V1e = 0;
1446 BYTE U2e = 0;
1447 BYTE V2e = 0;
1448 BYTE Y1o = 0;
1449 BYTE Y2o = 0;
1450 BYTE U1o = 0;
1451 BYTE V1o = 0;
1452 BYTE U2o = 0;
1453 BYTE V2o = 0;
1454 /* Read 4 pixels, 2 from even, 2 from odd lines */
1455 {
1456 const BYTE r = *srcEven++;
1457 const BYTE g = *srcEven++;
1458 const BYTE b = *srcEven++;
1459 srcEven++;
1460 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1461 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1462 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1463 }
1464
1465 if (!lastX)
1466 {
1467 const BYTE r = *srcEven++;
1468 const BYTE g = *srcEven++;
1469 const BYTE b = *srcEven++;
1470 srcEven++;
1471 Y2e = RGB2Y(r, g, b);
1472 U2e = RGB2U(r, g, b);
1473 V2e = RGB2V(r, g, b);
1474 }
1475
1476 if (b1Odd)
1477 {
1478 const BYTE r = *srcOdd++;
1479 const BYTE g = *srcOdd++;
1480 const BYTE b = *srcOdd++;
1481 srcOdd++;
1482 Y1o = Y2o = RGB2Y(r, g, b);
1483 U1o = U2o = RGB2U(r, g, b);
1484 V1o = V2o = RGB2V(r, g, b);
1485 }
1486
1487 if (b1Odd && !lastX)
1488 {
1489 const BYTE r = *srcOdd++;
1490 const BYTE g = *srcOdd++;
1491 const BYTE b = *srcOdd++;
1492 srcOdd++;
1493 Y2o = RGB2Y(r, g, b);
1494 U2o = RGB2U(r, g, b);
1495 V2o = RGB2V(r, g, b);
1496 }
1497
1498 /* We have 4 Y pixels, so store them. */
1499 *b1Even++ = Y1e;
1500 *b1Even++ = Y2e;
1501
1502 if (b1Odd)
1503 {
1504 *b1Odd++ = Y1o;
1505 *b1Odd++ = Y2o;
1506 }
1507
1508 /* 2x 2y pixel in luma UV plane use averaging
1509 */
1510 {
1511 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1512 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1513 *b2++ = Uavg;
1514 *b3++ = Vavg;
1515 }
1516
1517 /* UV from 2x, 2y+1 */
1518 if (b1Odd)
1519 {
1520 *b4++ = U1o;
1521 *b5++ = V1o;
1522
1523 if (!lastX)
1524 {
1525 *b4++ = U2o;
1526 *b5++ = V2o;
1527 }
1528 }
1529
1530 /* UV from 2x+1, 2y */
1531 if (!lastX)
1532 {
1533 *b6++ = U2e;
1534 *b7++ = V2e;
1535 }
1536 }
1537}
1538
1539static inline pstatus_t general_RGBToAVC444YUV_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1540 BYTE* WINPR_RESTRICT pDst1[3],
1541 const UINT32 dst1Step[3],
1542 BYTE* WINPR_RESTRICT pDst2[3],
1543 const UINT32 dst2Step[3],
1544 const prim_size_t* WINPR_RESTRICT roi)
1545{
1551 size_t y = 0;
1552 for (; y < roi->height - roi->height % 2; y += 2)
1553 {
1554 const BOOL last = (y >= (roi->height - 1));
1555 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1556 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1557 const size_t i = y >> 1;
1558 const size_t n = (i & (size_t)~7) + i;
1559 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1560 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : NULL;
1561 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1562 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1563 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1564 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1565 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1566 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1567 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5, b6,
1568 b7, roi->width);
1569 }
1570 for (; y < roi->height; y++)
1571 {
1572 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1573 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1574 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1575 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1576 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1577 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1578 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, NULL, b1Even, NULL, b2, b3, NULL, NULL, b6,
1579 b7, roi->width);
1580 }
1581 return PRIMITIVES_SUCCESS;
1582}
1583
1584static inline void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(
1585 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1586 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1587 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1588 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1589{
1590 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1591 for (UINT32 x = 0; x < width; x += 2)
1592 {
1593 const BOOL lastX = (x + 1) >= width;
1594 BYTE Y1e = 0;
1595 BYTE Y2e = 0;
1596 BYTE U1e = 0;
1597 BYTE V1e = 0;
1598 BYTE U2e = 0;
1599 BYTE V2e = 0;
1600 BYTE Y1o = 0;
1601 BYTE Y2o = 0;
1602 BYTE U1o = 0;
1603 BYTE V1o = 0;
1604 BYTE U2o = 0;
1605 BYTE V2o = 0;
1606 /* Read 4 pixels, 2 from even, 2 from odd lines */
1607 {
1608 BYTE r = 0;
1609 BYTE g = 0;
1610 BYTE b = 0;
1611 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1612 srcEven += bpp;
1613 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1614 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1615 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1616 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1617 }
1618
1619 if (!lastX)
1620 {
1621 BYTE r = 0;
1622 BYTE g = 0;
1623 BYTE b = 0;
1624 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1625 srcEven += bpp;
1626 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1627 Y2e = RGB2Y(r, g, b);
1628 U2e = RGB2U(r, g, b);
1629 V2e = RGB2V(r, g, b);
1630 }
1631
1632 if (b1Odd)
1633 {
1634 BYTE r = 0;
1635 BYTE g = 0;
1636 BYTE b = 0;
1637 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1638 srcOdd += bpp;
1639 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1640 Y1o = Y2o = RGB2Y(r, g, b);
1641 U1o = U2o = RGB2U(r, g, b);
1642 V1o = V2o = RGB2V(r, g, b);
1643 }
1644
1645 if (b1Odd && !lastX)
1646 {
1647 BYTE r = 0;
1648 BYTE g = 0;
1649 BYTE b = 0;
1650 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1651 srcOdd += bpp;
1652 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1653 Y2o = RGB2Y(r, g, b);
1654 U2o = RGB2U(r, g, b);
1655 V2o = RGB2V(r, g, b);
1656 }
1657
1658 /* We have 4 Y pixels, so store them. */
1659 *b1Even++ = Y1e;
1660 *b1Even++ = Y2e;
1661
1662 if (b1Odd)
1663 {
1664 *b1Odd++ = Y1o;
1665 *b1Odd++ = Y2o;
1666 }
1667
1668 /* 2x 2y pixel in luma UV plane use averaging
1669 */
1670 {
1671 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(
1672 BYTE, ((UINT16)U1e + (UINT16)U2e + (UINT16)U1o + (UINT16)U2o) / 4);
1673 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(
1674 BYTE, ((UINT16)V1e + (UINT16)V2e + (UINT16)V1o + (UINT16)V2o) / 4);
1675 *b2++ = Uavg;
1676 *b3++ = Vavg;
1677 }
1678
1679 /* UV from 2x, 2y+1 */
1680 if (b1Odd)
1681 {
1682 *b4++ = U1o;
1683 *b5++ = V1o;
1684
1685 if (!lastX)
1686 {
1687 *b4++ = U2o;
1688 *b5++ = V2o;
1689 }
1690 }
1691
1692 /* UV from 2x+1, 2y */
1693 if (!lastX)
1694 {
1695 *b6++ = U2e;
1696 *b7++ = V2e;
1697 }
1698 }
1699}
1700
1701static inline pstatus_t
1702general_RGBToAVC444YUV_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
1703 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
1704 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
1705 const prim_size_t* WINPR_RESTRICT roi)
1706{
1764 const BYTE* pMaxSrc = pSrc + 1ULL * (roi->height - 1) * srcStep;
1765
1766 for (size_t y = 0; y < roi->height; y += 2)
1767 {
1768 WINPR_ASSERT(y < UINT32_MAX);
1769
1770 const BOOL last = (y >= (roi->height - 1));
1771 const BYTE* srcEven = y < roi->height ? pSrc + y * srcStep : pMaxSrc;
1772 const BYTE* srcOdd = !last ? pSrc + (y + 1) * srcStep : pMaxSrc;
1773 const UINT32 i = (UINT32)y >> 1;
1774 const UINT32 n = (i & (uint32_t)~7) + i;
1775 BYTE* b1Even = pDst1[0] + y * dst1Step[0];
1776 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : NULL;
1777 BYTE* b2 = pDst1[1] + (y / 2) * dst1Step[1];
1778 BYTE* b3 = pDst1[2] + (y / 2) * dst1Step[2];
1779 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1780 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1781 BYTE* b6 = pDst2[1] + (y / 2) * dst2Step[1];
1782 BYTE* b7 = pDst2[2] + (y / 2) * dst2Step[2];
1783 general_RGBToAVC444YUV_ANY_DOUBLE_ROW(srcEven, srcOdd, srcFormat, b1Even, b1Odd, b2, b3, b4,
1784 b5, b6, b7, roi->width);
1785 }
1786
1787 return PRIMITIVES_SUCCESS;
1788}
1789
1790static inline pstatus_t general_RGBToAVC444YUV(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1791 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
1792 const UINT32 dst1Step[3],
1793 BYTE* WINPR_RESTRICT pDst2[3],
1794 const UINT32 dst2Step[3],
1795 const prim_size_t* WINPR_RESTRICT roi)
1796{
1797 if (!pSrc || !pDst1 || !dst1Step || !pDst2 || !dst2Step)
1798 return -1;
1799
1800 if (!pDst1[0] || !pDst1[1] || !pDst1[2])
1801 return -1;
1802
1803 if (!dst1Step[0] || !dst1Step[1] || !dst1Step[2])
1804 return -1;
1805
1806 if (!pDst2[0] || !pDst2[1] || !pDst2[2])
1807 return -1;
1808
1809 if (!dst2Step[0] || !dst2Step[1] || !dst2Step[2])
1810 return -1;
1811
1812 switch (srcFormat)
1813 {
1814
1815 case PIXEL_FORMAT_BGRA32:
1816 case PIXEL_FORMAT_BGRX32:
1817 return general_RGBToAVC444YUV_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1818 roi);
1819
1820 case PIXEL_FORMAT_RGBA32:
1821 case PIXEL_FORMAT_RGBX32:
1822 return general_RGBToAVC444YUV_RGBX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1823 roi);
1824
1825 default:
1826 return general_RGBToAVC444YUV_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
1827 dst2Step, roi);
1828 }
1829
1830 return !PRIMITIVES_SUCCESS;
1831}
1832
1833static inline void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
1834 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1835 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
1836 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
1837 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
1838 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
1839 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
1840 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
1841{
1842 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1843
1844 WINPR_ASSERT((width % 2) == 0);
1845 for (UINT32 x = 0; x < width; x += 2)
1846 {
1847 BYTE Ya = 0;
1848 BYTE Ua = 0;
1849 BYTE Va = 0;
1850 BYTE Yb = 0;
1851 BYTE Ub = 0;
1852 BYTE Vb = 0;
1853 BYTE Yc = 0;
1854 BYTE Uc = 0;
1855 BYTE Vc = 0;
1856 BYTE Yd = 0;
1857 BYTE Ud = 0;
1858 BYTE Vd = 0;
1859 {
1860 BYTE b = 0;
1861 BYTE g = 0;
1862 BYTE r = 0;
1863 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1864 srcEven += bpp;
1865 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1866 Ya = RGB2Y(r, g, b);
1867 Ua = RGB2U(r, g, b);
1868 Va = RGB2V(r, g, b);
1869 }
1870
1871 if (x < width - 1)
1872 {
1873 BYTE b = 0;
1874 BYTE g = 0;
1875 BYTE r = 0;
1876 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1877 srcEven += bpp;
1878 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1879 Yb = RGB2Y(r, g, b);
1880 Ub = RGB2U(r, g, b);
1881 Vb = RGB2V(r, g, b);
1882 }
1883 else
1884 {
1885 Yb = Ya;
1886 Ub = Ua;
1887 Vb = Va;
1888 }
1889
1890 if (srcOdd)
1891 {
1892 BYTE b = 0;
1893 BYTE g = 0;
1894 BYTE r = 0;
1895 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1896 srcOdd += bpp;
1897 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1898 Yc = RGB2Y(r, g, b);
1899 Uc = RGB2U(r, g, b);
1900 Vc = RGB2V(r, g, b);
1901 }
1902 else
1903 {
1904 Yc = Ya;
1905 Uc = Ua;
1906 Vc = Va;
1907 }
1908
1909 if (srcOdd && (x < width - 1))
1910 {
1911 BYTE b = 0;
1912 BYTE g = 0;
1913 BYTE r = 0;
1914 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1915 srcOdd += bpp;
1916 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, NULL, NULL);
1917 Yd = RGB2Y(r, g, b);
1918 Ud = RGB2U(r, g, b);
1919 Vd = RGB2V(r, g, b);
1920 }
1921 else
1922 {
1923 Yd = Ya;
1924 Ud = Ua;
1925 Vd = Va;
1926 }
1927
1928 /* Y [b1] */
1929 *yLumaDstEven++ = Ya;
1930
1931 if (x < width - 1)
1932 *yLumaDstEven++ = Yb;
1933
1934 if (srcOdd)
1935 *yLumaDstOdd++ = Yc;
1936
1937 if (srcOdd && (x < width - 1))
1938 *yLumaDstOdd++ = Yd;
1939
1940 /* 2x 2y [b2,b3] */
1941 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
1942 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
1943
1944 /* 2x+1, y [b4,b5] even */
1945 if (x < width - 1)
1946 {
1947 *yEvenChromaDst1++ = Ub;
1948 *yEvenChromaDst2++ = Vb;
1949 }
1950
1951 if (srcOdd)
1952 {
1953 /* 2x+1, y [b4,b5] odd */
1954 if (x < width - 1)
1955 {
1956 *yOddChromaDst1++ = Ud;
1957 *yOddChromaDst2++ = Vd;
1958 }
1959
1960 /* 4x 2y+1 [b6, b7] */
1961 if (x % 4 == 0)
1962 {
1963 *uChromaDst1++ = Uc;
1964 *uChromaDst2++ = Vc;
1965 }
1966 /* 4x+2 2y+1 [b8, b9] */
1967 else
1968 {
1969 *vChromaDst1++ = Uc;
1970 *vChromaDst2++ = Vc;
1971 }
1972 }
1973 }
1974}
1975
1976static inline pstatus_t
1977general_RGBToAVC444YUVv2_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
1978 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
1979 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
1980 const prim_size_t* WINPR_RESTRICT roi)
1981{
2032 if (roi->height < 1 || roi->width < 1)
2033 return !PRIMITIVES_SUCCESS;
2034
2035 size_t y = 0;
2036 for (; y < roi->height - roi->height % 2; y += 2)
2037 {
2038 const BYTE* srcEven = (pSrc + y * srcStep);
2039 const BYTE* srcOdd = (y < roi->height - 1) ? (srcEven + srcStep) : NULL;
2040 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2041 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2042 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2043 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2044 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2045 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2046 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2047 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2048 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2049 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2050 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2051 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2052 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2053 srcEven, srcOdd, srcFormat, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV,
2054 dstEvenChromaY1, dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1,
2055 dstChromaU2, dstChromaV1, dstChromaV2, roi->width);
2056 }
2057 for (; y < roi->height; y++)
2058 {
2059 const BYTE* srcEven = (pSrc + y * srcStep);
2060 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2061 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2062 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2063 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2064 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2065 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2066 srcEven, NULL, srcFormat, dstLumaYEven, NULL, dstLumaU, dstLumaV, dstEvenChromaY1,
2067 dstEvenChromaY2, NULL, NULL, NULL, NULL, NULL, NULL, roi->width);
2068 }
2069
2070 return PRIMITIVES_SUCCESS;
2071}
2072
2073static inline void int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2074 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2075 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2076 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2077 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2078 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2079 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2080 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2081{
2082 WINPR_ASSERT((width % 2) == 0);
2083 WINPR_ASSERT(pSrcEven);
2084 WINPR_ASSERT(yLumaDstEven);
2085 WINPR_ASSERT(uLumaDst);
2086 WINPR_ASSERT(vLumaDst);
2087
2088 for (size_t x = offset; x < width; x += 2)
2089 {
2090 const BYTE* srcEven = &pSrcEven[4ULL * x];
2091 const BYTE* srcOdd = pSrcOdd ? &pSrcOdd[4ULL * x] : NULL;
2092 BYTE Ya = 0;
2093 BYTE Ua = 0;
2094 BYTE Va = 0;
2095 BYTE Yb = 0;
2096 BYTE Ub = 0;
2097 BYTE Vb = 0;
2098 BYTE Yc = 0;
2099 BYTE Uc = 0;
2100 BYTE Vc = 0;
2101 BYTE Yd = 0;
2102 BYTE Ud = 0;
2103 BYTE Vd = 0;
2104 {
2105 const BYTE b = *srcEven++;
2106 const BYTE g = *srcEven++;
2107 const BYTE r = *srcEven++;
2108 srcEven++;
2109 Ya = RGB2Y(r, g, b);
2110 Ua = RGB2U(r, g, b);
2111 Va = RGB2V(r, g, b);
2112 }
2113
2114 if (x < width - 1)
2115 {
2116 const BYTE b = *srcEven++;
2117 const BYTE g = *srcEven++;
2118 const BYTE r = *srcEven++;
2119 srcEven++;
2120 Yb = RGB2Y(r, g, b);
2121 Ub = RGB2U(r, g, b);
2122 Vb = RGB2V(r, g, b);
2123 }
2124 else
2125 {
2126 Yb = Ya;
2127 Ub = Ua;
2128 Vb = Va;
2129 }
2130
2131 if (srcOdd)
2132 {
2133 const BYTE b = *srcOdd++;
2134 const BYTE g = *srcOdd++;
2135 const BYTE r = *srcOdd++;
2136 srcOdd++;
2137 Yc = RGB2Y(r, g, b);
2138 Uc = RGB2U(r, g, b);
2139 Vc = RGB2V(r, g, b);
2140 }
2141 else
2142 {
2143 Yc = Ya;
2144 Uc = Ua;
2145 Vc = Va;
2146 }
2147
2148 if (srcOdd && (x < width - 1))
2149 {
2150 const BYTE b = *srcOdd++;
2151 const BYTE g = *srcOdd++;
2152 const BYTE r = *srcOdd++;
2153 srcOdd++;
2154 Yd = RGB2Y(r, g, b);
2155 Ud = RGB2U(r, g, b);
2156 Vd = RGB2V(r, g, b);
2157 }
2158 else
2159 {
2160 Yd = Ya;
2161 Ud = Ua;
2162 Vd = Va;
2163 }
2164
2165 /* Y [b1] */
2166 *yLumaDstEven++ = Ya;
2167
2168 if (x < width - 1)
2169 *yLumaDstEven++ = Yb;
2170
2171 if (srcOdd && yLumaDstOdd)
2172 *yLumaDstOdd++ = Yc;
2173
2174 if (srcOdd && (x < width - 1) && yLumaDstOdd)
2175 *yLumaDstOdd++ = Yd;
2176
2177 /* 2x 2y [b2,b3] */
2178 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2179 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2180
2181 /* 2x+1, y [b4,b5] even */
2182 if (x < width - 1)
2183 {
2184 *yEvenChromaDst1++ = Ub;
2185 *yEvenChromaDst2++ = Vb;
2186 }
2187
2188 if (srcOdd)
2189 {
2190 /* 2x+1, y [b4,b5] odd */
2191 if (x < width - 1)
2192 {
2193 *yOddChromaDst1++ = Ud;
2194 *yOddChromaDst2++ = Vd;
2195 }
2196
2197 /* 4x 2y+1 [b6, b7] */
2198 if (x % 4 == 0)
2199 {
2200 *uChromaDst1++ = Uc;
2201 *uChromaDst2++ = Vc;
2202 }
2203 /* 4x+2 2y+1 [b8, b9] */
2204 else
2205 {
2206 *vChromaDst1++ = Uc;
2207 *vChromaDst2++ = Vc;
2208 }
2209 }
2210 }
2211}
2212
2213void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2214 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2215 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2216 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2217 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2218 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2219 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2220 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2221{
2222 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2223 offset, pSrcEven, pSrcOdd, yLumaDstEven, yLumaDstOdd, uLumaDst, vLumaDst, yEvenChromaDst1,
2224 yEvenChromaDst2, yOddChromaDst1, yOddChromaDst2, uChromaDst1, uChromaDst2, vChromaDst1,
2225 vChromaDst2, width);
2226}
2227
2228static inline pstatus_t general_RGBToAVC444YUVv2_BGRX(const BYTE* WINPR_RESTRICT pSrc,
2229 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2230 const UINT32 dst1Step[3],
2231 BYTE* WINPR_RESTRICT pDst2[3],
2232 const UINT32 dst2Step[3],
2233 const prim_size_t* WINPR_RESTRICT roi)
2234{
2235 if (roi->height < 1 || roi->width < 1)
2236 return !PRIMITIVES_SUCCESS;
2237
2238 size_t y = 0;
2239 for (; y < roi->height - roi->height % 2; y += 2)
2240 {
2241 const BYTE* srcEven = (pSrc + y * srcStep);
2242 const BYTE* srcOdd = (srcEven + srcStep);
2243 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2244 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2245 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2246 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2247 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2248 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2249 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2250 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2251 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2252 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2253 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2254 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2255 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2256 0, srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
2257 dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1, dstChromaU2, dstChromaV1,
2258 dstChromaV2, roi->width);
2259 }
2260 for (; y < roi->height; y++)
2261 {
2262 const BYTE* srcEven = (pSrc + y * srcStep);
2263 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2264 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2265 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2266 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2267 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2268 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2269 0, srcEven, NULL, dstLumaYEven, NULL, dstLumaU, dstLumaV, dstEvenChromaY1,
2270 dstEvenChromaY2, NULL, NULL, NULL, NULL, NULL, NULL, roi->width);
2271 }
2272
2273 return PRIMITIVES_SUCCESS;
2274}
2275
2276static pstatus_t general_RGBToAVC444YUVv2(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
2277 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2278 const UINT32 dst1Step[3], BYTE* WINPR_RESTRICT pDst2[3],
2279 const UINT32 dst2Step[3],
2280 const prim_size_t* WINPR_RESTRICT roi)
2281{
2282 switch (srcFormat)
2283 {
2284 case PIXEL_FORMAT_BGRA32:
2285 case PIXEL_FORMAT_BGRX32:
2286 return general_RGBToAVC444YUVv2_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
2287 roi);
2288
2289 default:
2290 return general_RGBToAVC444YUVv2_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
2291 dst2Step, roi);
2292 }
2293
2294 return !PRIMITIVES_SUCCESS;
2295}
2296
2297void primitives_init_YUV(primitives_t* WINPR_RESTRICT prims)
2298{
2299 prims->YUV420ToRGB_8u_P3AC4R = general_YUV420ToRGB_8u_P3AC4R;
2300 prims->YUV444ToRGB_8u_P3AC4R = general_YUV444ToRGB_8u_P3AC4R;
2301 prims->RGBToYUV420_8u_P3AC4R = general_RGBToYUV420_8u_P3AC4R;
2302 prims->RGBToYUV444_8u_P3AC4R = general_RGBToYUV444_8u_P3AC4R;
2303 prims->YUV420CombineToYUV444 = general_YUV420CombineToYUV444;
2304 prims->YUV444SplitToYUV420 = general_YUV444SplitToYUV420;
2305 prims->RGBToAVC444YUV = general_RGBToAVC444YUV;
2306 prims->RGBToAVC444YUVv2 = general_RGBToAVC444YUVv2;
2307}
2308
2309void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims)
2310{
2311 primitives_init_YUV(prims);
2312 primitives_init_YUV_sse41(prims);
2313 primitives_init_YUV_neon(prims);
2314}
RECTANGLE_16
Definition types.h:109
prim_size_t
Definition primitives.h:74
primitives_t
Definition primitives.h:255