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 = nullptr;
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 void general_YUV420ToRGB_8u_P3AC4R_double_line(BYTE* WINPR_RESTRICT pEven,
538 BYTE* WINPR_RESTRICT pOdd, UINT32 DstFormat,
539 const BYTE* WINPR_RESTRICT pYeven,
540 const BYTE* WINPR_RESTRICT pYodd,
541 const BYTE* WINPR_RESTRICT pU,
542 const BYTE* WINPR_RESTRICT pV, UINT32 width,
543 fkt_writePixel writePixel, UINT32 formatSize)
544{
545
546 UINT32 x = 0;
547 for (; x < width / 2; x++)
548 {
549 const BYTE U = pU[x];
550 const BYTE V = pV[x];
551 const BYTE eY0 = pYeven[2ULL * x + 0];
552 const BYTE eY1 = pYeven[2ULL * x + 1];
553 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
554 writeYUVPixel(&pEven[(2ULL * x + 1) * formatSize], DstFormat, eY1, U, V, writePixel);
555
556 const BYTE oY0 = pYodd[2ULL * x + 0];
557 const BYTE oY1 = pYodd[2ULL * x + 1];
558 writeYUVPixel(&pOdd[2ULL * x * formatSize], DstFormat, oY0, U, V, writePixel);
559 writeYUVPixel(&pOdd[(2ULL * x + 1) * formatSize], DstFormat, oY1, U, V, writePixel);
560 }
561
562 for (; x < (width + 1) / 2; x++)
563 {
564 const BYTE U = pU[x];
565 const BYTE V = pV[x];
566 const BYTE eY0 = pYeven[2ULL * x + 0];
567 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
568
569 const BYTE oY0 = pYodd[2ULL * x + 0];
570 writeYUVPixel(&pOdd[2ULL * x * formatSize], DstFormat, oY0, U, V, writePixel);
571 }
572}
573
574static void general_YUV420ToRGB_8u_P3AC4R_single_line(BYTE* WINPR_RESTRICT pEven, UINT32 DstFormat,
575 const BYTE* WINPR_RESTRICT pYeven,
576 const BYTE* WINPR_RESTRICT pU,
577 const BYTE* WINPR_RESTRICT pV, UINT32 width,
578 fkt_writePixel writePixel, UINT32 formatSize)
579{
580
581 UINT32 x = 0;
582 for (; x < width / 2; x++)
583 {
584 const BYTE U = pU[x];
585 const BYTE V = pV[x];
586 const BYTE eY0 = pYeven[2ULL * x + 0];
587 const BYTE eY1 = pYeven[2ULL * x + 1];
588 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
589 writeYUVPixel(&pEven[(2ULL * x + 1) * formatSize], DstFormat, eY1, U, V, writePixel);
590 }
591
592 for (; x < (width + 1) / 2; x++)
593 {
594 const BYTE U = pU[x];
595 const BYTE V = pV[x];
596 const BYTE eY0 = pYeven[2ULL * x + 0];
597 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
598 }
599}
600
601static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
602 const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
603 UINT32 dstStep, UINT32 DstFormat,
604 const prim_size_t* WINPR_RESTRICT roi)
605{
606 WINPR_ASSERT(roi);
607 const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
608 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
609 const UINT32 nWidth = roi->width;
610 const UINT32 nHeight = roi->height;
611
612 UINT32 y = 0;
613 for (; y < nHeight / 2; y++)
614 {
615 const BYTE* pYe = &pSrc[0][(2ULL * y + 0) * srcStep[0]];
616 const BYTE* pYo = &pSrc[0][(2ULL * y + 1) * srcStep[0]];
617 const BYTE* pU = &pSrc[1][1ULL * srcStep[1] * y];
618 const BYTE* pV = &pSrc[2][1ULL * srcStep[2] * y];
619 BYTE* pRGBeven = &pDst[2ULL * y * dstStep];
620 BYTE* pRGBodd = &pDst[(2ULL * y + 1) * dstStep];
621 general_YUV420ToRGB_8u_P3AC4R_double_line(pRGBeven, pRGBodd, DstFormat, pYe, pYo, pU, pV,
622 nWidth, writePixel, formatSize);
623 }
624
625 // Last row (if odd)
626 for (; y < (nHeight + 1) / 2; y++)
627 {
628 const BYTE* pY = &pSrc[0][2ULL * srcStep[0] * y];
629 const BYTE* pU = &pSrc[1][1ULL * srcStep[1] * y];
630 const BYTE* pV = &pSrc[2][1ULL * srcStep[2] * y];
631 BYTE* pEven = &pDst[2ULL * y * dstStep];
632
633 general_YUV420ToRGB_8u_P3AC4R_single_line(pEven, DstFormat, pY, pU, pV, nWidth, writePixel,
634 formatSize);
635 }
636
637 return PRIMITIVES_SUCCESS;
638}
639
640static inline void BGRX_fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2],
641 BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
642 BYTE* WINPR_RESTRICT pV[2])
643{
644 WINPR_ASSERT(pRGB);
645 WINPR_ASSERT(pY);
646 WINPR_ASSERT(pU);
647 WINPR_ASSERT(pV);
648
649 const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
650 const UINT32 bpp = 4;
651
652 for (size_t i = 0; i < 2; i++)
653 {
654 for (size_t j = 0; j < 2; j++)
655 {
656 BYTE B = 0;
657 BYTE G = 0;
658 BYTE R = 0;
659 const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
660 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
661 pY[i][offset + j] = RGB2Y(R, G, B);
662 pU[i][offset + j] = RGB2U(R, G, B);
663 pV[i][offset + j] = RGB2V(R, G, B);
664 }
665 }
666
667 /* Apply chroma filter */
668 const INT32 avgU = (pU[0][offset] + pU[0][offset + 1] + pU[1][offset] + pU[1][offset + 1]) / 4;
669 pU[0][offset] = CONDITIONAL_CLIP(avgU, pU[0][offset]);
670 const INT32 avgV = (pV[0][offset] + pV[0][offset + 1] + pV[1][offset] + pV[1][offset + 1]) / 4;
671 pV[0][offset] = CONDITIONAL_CLIP(avgV, pV[0][offset]);
672}
673
674static inline void BGRX_fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB,
675 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
676 BYTE* WINPR_RESTRICT pV)
677{
678 WINPR_ASSERT(pRGB);
679 WINPR_ASSERT(pY);
680 WINPR_ASSERT(pU);
681 WINPR_ASSERT(pV);
682
683 const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
684 const UINT32 bpp = 4;
685
686 for (size_t j = 0; j < 2; j++)
687 {
688 BYTE B = 0;
689 BYTE G = 0;
690 BYTE R = 0;
691 const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
692 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
693 pY[offset + j] = RGB2Y(R, G, B);
694 pU[offset + j] = RGB2U(R, G, B);
695 pV[offset + j] = RGB2V(R, G, B);
696 }
697}
698
699static inline void general_BGRXToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
700 BYTE* WINPR_RESTRICT pY[2],
701 BYTE* WINPR_RESTRICT pU[2],
702 BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
703{
704
705 WINPR_ASSERT((nWidth % 2) == 0);
706 for (size_t x = 0; x < nWidth; x += 2)
707 {
708 BGRX_fillYUV(x, pRGB, pY, pU, pV);
709 }
710}
711
712static inline void general_BGRXToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB,
713 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
714 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
715{
716
717 WINPR_ASSERT((nWidth % 2) == 0);
718 for (size_t x = 0; x < nWidth; x += 2)
719 {
720 BGRX_fillYUV_single(x, pRGB, pY, pU, pV);
721 }
722}
723
724static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc,
725 const UINT32 srcStep,
726 BYTE* WINPR_RESTRICT pDst[3],
727 const UINT32 dstStep[3],
728 const prim_size_t* WINPR_RESTRICT roi)
729{
730 const UINT32 nWidth = roi->width;
731 const UINT32 nHeight = roi->height;
732
733 size_t y = 0;
734 for (; y < nHeight - nHeight % 2; y += 2)
735 {
736 const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
737 BYTE* pY[] = { pDst[0] + y * dstStep[0], pDst[0] + (y + 1) * dstStep[0] };
738 BYTE* pU[] = { pDst[1] + y * dstStep[1], pDst[1] + (y + 1) * dstStep[1] };
739 BYTE* pV[] = { pDst[2] + y * dstStep[2], pDst[2] + (y + 1) * dstStep[2] };
740
741 general_BGRXToYUV444_DOUBLE_ROW(pRGB, pY, pU, pV, nWidth);
742 }
743
744 for (; y < nHeight; y++)
745 {
746 const BYTE* pRGB = pSrc + y * srcStep;
747 BYTE* pY = pDst[0] + y * dstStep[0];
748 BYTE* pU = pDst[1] + y * dstStep[1];
749 BYTE* pV = pDst[2] + y * dstStep[2];
750
751 general_BGRXToYUV444_SINGLE_ROW(pRGB, pY, pU, pV, nWidth);
752 }
753
754 return PRIMITIVES_SUCCESS;
755}
756
757static inline void fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2], UINT32 SrcFormat,
758 BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
759 BYTE* WINPR_RESTRICT pV[2])
760{
761 WINPR_ASSERT(pRGB);
762 WINPR_ASSERT(pY);
763 WINPR_ASSERT(pU);
764 WINPR_ASSERT(pV);
765 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
766
767 INT32 avgU = 0;
768 INT32 avgV = 0;
769 for (size_t i = 0; i < 2; i++)
770 {
771 for (size_t j = 0; j < 2; j++)
772 {
773 BYTE B = 0;
774 BYTE G = 0;
775 BYTE R = 0;
776 const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
777 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
778 const BYTE y = RGB2Y(R, G, B);
779 const BYTE u = RGB2U(R, G, B);
780 const BYTE v = RGB2V(R, G, B);
781 avgU += u;
782 avgV += v;
783 pY[i][offset + j] = y;
784 pU[i][offset + j] = u;
785 pV[i][offset + j] = v;
786 }
787 }
788
789 /* Apply chroma filter */
790 avgU /= 4;
791 pU[0][offset] = CLIP(avgU);
792
793 avgV /= 4;
794 pV[0][offset] = CLIP(avgV);
795}
796
797static inline void fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
798 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
799 BYTE* WINPR_RESTRICT pV)
800{
801 WINPR_ASSERT(pRGB);
802 WINPR_ASSERT(pY);
803 WINPR_ASSERT(pU);
804 WINPR_ASSERT(pV);
805 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
806
807 for (size_t j = 0; j < 2; j++)
808 {
809 BYTE B = 0;
810 BYTE G = 0;
811 BYTE R = 0;
812 const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
813 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
814 const BYTE y = RGB2Y(R, G, B);
815 const BYTE u = RGB2U(R, G, B);
816 const BYTE v = RGB2V(R, G, B);
817 pY[offset + j] = y;
818 pU[offset + j] = u;
819 pV[offset + j] = v;
820 }
821}
822
823static inline void general_RGBToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
824 UINT32 SrcFormat, BYTE* WINPR_RESTRICT pY[2],
825 BYTE* WINPR_RESTRICT pU[2],
826 BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
827{
828
829 WINPR_ASSERT((nWidth % 2) == 0);
830 for (size_t x = 0; x < nWidth; x += 2)
831 {
832 fillYUV(x, pRGB, SrcFormat, pY, pU, pV);
833 }
834}
835
836static inline void general_RGBToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
837 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
838 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
839{
840
841 WINPR_ASSERT((nWidth % 2) == 0);
842 for (size_t x = 0; x < nWidth; x += 2)
843 {
844 fillYUV_single(x, pRGB, SrcFormat, pY, pU, pV);
845 }
846}
847
848static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_RGB(const BYTE* WINPR_RESTRICT pSrc,
849 UINT32 SrcFormat, const UINT32 srcStep,
850 BYTE* WINPR_RESTRICT pDst[3],
851 const UINT32 dstStep[3],
852 const prim_size_t* WINPR_RESTRICT roi)
853{
854 const UINT32 nWidth = roi->width;
855 const UINT32 nHeight = roi->height;
856
857 size_t y = 0;
858 for (; y < nHeight - nHeight % 2; y += 2)
859 {
860 const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
861 BYTE* pY[] = { &pDst[0][y * dstStep[0]], &pDst[0][(y + 1) * dstStep[0]] };
862 BYTE* pU[] = { &pDst[1][y * dstStep[1]], &pDst[1][(y + 1) * dstStep[1]] };
863 BYTE* pV[] = { &pDst[2][y * dstStep[2]], &pDst[2][(y + 1) * dstStep[2]] };
864
865 general_RGBToYUV444_DOUBLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
866 }
867 for (; y < nHeight; y++)
868 {
869 const BYTE* pRGB = pSrc + y * srcStep;
870 BYTE* pY = &pDst[0][y * dstStep[0]];
871 BYTE* pU = &pDst[1][y * dstStep[1]];
872 BYTE* pV = &pDst[2][y * dstStep[2]];
873
874 general_RGBToYUV444_SINGLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
875 }
876
877 return PRIMITIVES_SUCCESS;
878}
879
880static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
881 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
882 const UINT32 dstStep[3],
883 const prim_size_t* WINPR_RESTRICT roi)
884{
885 switch (SrcFormat)
886 {
887 case PIXEL_FORMAT_BGRA32:
888 case PIXEL_FORMAT_BGRX32:
889 return general_RGBToYUV444_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, roi);
890 default:
891 return general_RGBToYUV444_8u_P3AC4R_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
892 }
893}
894
895static inline void fillI444_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
896 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
897 BYTE* WINPR_RESTRICT pV)
898{
899 WINPR_ASSERT(pRGB);
900 WINPR_ASSERT(pY);
901 WINPR_ASSERT(pU);
902 WINPR_ASSERT(pV);
903
904 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
905
906 BYTE B = 0;
907 BYTE G = 0;
908 BYTE R = 0;
909 const UINT32 color = FreeRDPReadColor(&pRGB[offset * bpp], SrcFormat);
910 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
911 const BYTE y = RGB2Y(R, G, B);
912 const BYTE u = RGB2U(R, G, B);
913 const BYTE v = RGB2V(R, G, B);
914 pY[offset] = y;
915 pU[offset] = u;
916 pV[offset] = v;
917}
918
919static inline void general_RGBToI444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
920 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
921 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
922{
923 for (size_t x = 0; x < nWidth; x++)
924 {
925 fillI444_single(x, pRGB, SrcFormat, pY, pU, pV);
926 }
927}
928
929static inline pstatus_t general_RGBToI444_8u_RGB(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
930 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
931 const UINT32 dstStep[3],
932 const prim_size_t* WINPR_RESTRICT roi)
933{
934 const UINT32 nWidth = roi->width;
935 const UINT32 nHeight = roi->height;
936
937 for (size_t y = 0; y < nHeight; y++)
938 {
939 const BYTE* pRGB = pSrc + y * srcStep;
940 BYTE* pY = &pDst[0][y * dstStep[0]];
941 BYTE* pU = &pDst[1][y * dstStep[1]];
942 BYTE* pV = &pDst[2][y * dstStep[2]];
943
944 general_RGBToI444_SINGLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
945 }
946
947 return PRIMITIVES_SUCCESS;
948}
949
950static pstatus_t general_RGBToI444_8u(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
951 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
952 const UINT32 dstStep[3],
953 const prim_size_t* WINPR_RESTRICT roi)
954{
955 switch (SrcFormat)
956 {
957 default:
958 return general_RGBToI444_8u_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
959 }
960}
961
962static inline pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
963 BYTE* WINPR_RESTRICT pDst[3],
964 const UINT32 dstStep[3],
965 const prim_size_t* WINPR_RESTRICT roi)
966{
967 size_t x1 = 0;
968 size_t x2 = 4;
969 size_t x3 = srcStep;
970 size_t x4 = srcStep + 4;
971 size_t y1 = 0;
972 size_t y2 = 1;
973 size_t y3 = dstStep[0];
974 size_t y4 = dstStep[0] + 1;
975 UINT32 max_x = roi->width - 1;
976
977 size_t y = 0;
978 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
979 {
980 const BYTE* src = pSrc + y * srcStep;
981 BYTE* ydst = pDst[0] + y * dstStep[0];
982 BYTE* udst = pDst[1] + i * dstStep[1];
983 BYTE* vdst = pDst[2] + i * dstStep[2];
984
985 for (size_t x = 0; x < roi->width; x += 2)
986 {
987 BYTE R = 0;
988 BYTE G = 0;
989 BYTE B = 0;
990 INT32 Ra = 0;
991 INT32 Ga = 0;
992 INT32 Ba = 0;
993 /* row 1, pixel 1 */
994 Ba = B = *(src + x1 + 0);
995 Ga = G = *(src + x1 + 1);
996 Ra = R = *(src + x1 + 2);
997 ydst[y1] = RGB2Y(R, G, B);
998
999 if (x < max_x)
1000 {
1001 /* row 1, pixel 2 */
1002 Ba += B = *(src + x2 + 0);
1003 Ga += G = *(src + x2 + 1);
1004 Ra += R = *(src + x2 + 2);
1005 ydst[y2] = RGB2Y(R, G, B);
1006 }
1007
1008 /* row 2, pixel 1 */
1009 Ba += B = *(src + x3 + 0);
1010 Ga += G = *(src + x3 + 1);
1011 Ra += R = *(src + x3 + 2);
1012 ydst[y3] = RGB2Y(R, G, B);
1013
1014 if (x < max_x)
1015 {
1016 /* row 2, pixel 2 */
1017 Ba += B = *(src + x4 + 0);
1018 Ga += G = *(src + x4 + 1);
1019 Ra += R = *(src + x4 + 2);
1020 ydst[y4] = RGB2Y(R, G, B);
1021 }
1022
1023 Ba >>= 2;
1024 Ga >>= 2;
1025 Ra >>= 2;
1026 *udst++ = RGB2U(Ra, Ga, Ba);
1027 *vdst++ = RGB2V(Ra, Ga, Ba);
1028 ydst += 2;
1029 src += 8;
1030 }
1031 }
1032
1033 for (; y < roi->height; y++)
1034 {
1035 const BYTE* src = pSrc + y * srcStep;
1036 BYTE* ydst = pDst[0] + y * dstStep[0];
1037 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1038 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1039
1040 for (size_t x = 0; x < roi->width; x += 2)
1041 {
1042 BYTE R = 0;
1043 BYTE G = 0;
1044 BYTE B = 0;
1045 INT32 Ra = 0;
1046 INT32 Ga = 0;
1047 INT32 Ba = 0;
1048 /* row 1, pixel 1 */
1049 Ba = B = *(src + x1 + 0);
1050 Ga = G = *(src + x1 + 1);
1051 Ra = R = *(src + x1 + 2);
1052 ydst[y1] = RGB2Y(R, G, B);
1053
1054 if (x < max_x)
1055 {
1056 /* row 1, pixel 2 */
1057 Ba += B = *(src + x2 + 0);
1058 Ga += G = *(src + x2 + 1);
1059 Ra += R = *(src + x2 + 2);
1060 ydst[y2] = RGB2Y(R, G, B);
1061 }
1062
1063 Ba >>= 2;
1064 Ga >>= 2;
1065 Ra >>= 2;
1066 *udst++ = RGB2U(Ra, Ga, Ba);
1067 *vdst++ = RGB2V(Ra, Ga, Ba);
1068 ydst += 2;
1069 src += 8;
1070 }
1071 }
1072
1073 return PRIMITIVES_SUCCESS;
1074}
1075
1076static inline pstatus_t general_RGBToYUV420_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1077 BYTE* WINPR_RESTRICT pDst[3],
1078 const UINT32 dstStep[3],
1079 const prim_size_t* WINPR_RESTRICT roi)
1080{
1081 size_t x1 = 0;
1082 size_t x2 = 4;
1083 size_t x3 = srcStep;
1084 size_t x4 = srcStep + 4;
1085 size_t y1 = 0;
1086 size_t y2 = 1;
1087 size_t y3 = dstStep[0];
1088 size_t y4 = dstStep[0] + 1;
1089 UINT32 max_x = roi->width - 1;
1090
1091 size_t y = 0;
1092 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1093 {
1094 const BYTE* src = pSrc + y * srcStep;
1095 BYTE* ydst = pDst[0] + y * dstStep[0];
1096 BYTE* udst = pDst[1] + i * dstStep[1];
1097 BYTE* vdst = pDst[2] + i * dstStep[2];
1098
1099 for (UINT32 x = 0; x < roi->width; x += 2)
1100 {
1101 BYTE R = *(src + x1 + 0);
1102 BYTE G = *(src + x1 + 1);
1103 BYTE B = *(src + x1 + 2);
1104 /* row 1, pixel 1 */
1105 INT32 Ra = R;
1106 INT32 Ga = G;
1107 INT32 Ba = B;
1108 ydst[y1] = RGB2Y(R, G, B);
1109
1110 if (x < max_x)
1111 {
1112 /* row 1, pixel 2 */
1113 R = *(src + x2 + 0);
1114 G = *(src + x2 + 1);
1115 B = *(src + x2 + 2);
1116 Ra += R;
1117 Ga += G;
1118 Ba += B;
1119 ydst[y2] = RGB2Y(R, G, B);
1120 }
1121
1122 /* row 2, pixel 1 */
1123 R = *(src + x3 + 0);
1124 G = *(src + x3 + 1);
1125 B = *(src + x3 + 2);
1126
1127 Ra += R;
1128 Ga += G;
1129 Ba += B;
1130 ydst[y3] = RGB2Y(R, G, B);
1131
1132 if (x < max_x)
1133 {
1134 /* row 2, pixel 2 */
1135 R = *(src + x4 + 0);
1136 G = *(src + x4 + 1);
1137 B = *(src + x4 + 2);
1138
1139 Ra += R;
1140 Ga += G;
1141 Ba += B;
1142 ydst[y4] = RGB2Y(R, G, B);
1143 }
1144
1145 Ba >>= 2;
1146 Ga >>= 2;
1147 Ra >>= 2;
1148 *udst++ = RGB2U(Ra, Ga, Ba);
1149 *vdst++ = RGB2V(Ra, Ga, Ba);
1150 ydst += 2;
1151 src += 8;
1152 }
1153 }
1154
1155 for (; y < roi->height; y++)
1156 {
1157 const BYTE* src = pSrc + y * srcStep;
1158 BYTE* ydst = pDst[0] + y * dstStep[0];
1159 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1160 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1161
1162 for (UINT32 x = 0; x < roi->width; x += 2)
1163 {
1164 BYTE R = *(src + x1 + 0);
1165 BYTE G = *(src + x1 + 1);
1166 BYTE B = *(src + x1 + 2);
1167 /* row 1, pixel 1 */
1168 INT32 Ra = R;
1169 INT32 Ga = G;
1170 INT32 Ba = B;
1171 ydst[y1] = RGB2Y(R, G, B);
1172
1173 if (x < max_x)
1174 {
1175 /* row 1, pixel 2 */
1176 R = *(src + x2 + 0);
1177 G = *(src + x2 + 1);
1178 B = *(src + x2 + 2);
1179 Ra += R;
1180 Ga += G;
1181 Ba += B;
1182 ydst[y2] = RGB2Y(R, G, B);
1183 }
1184
1185 Ba >>= 2;
1186 Ga >>= 2;
1187 Ra >>= 2;
1188 *udst++ = RGB2U(Ra, Ga, Ba);
1189 *vdst++ = RGB2V(Ra, Ga, Ba);
1190 ydst += 2;
1191 src += 8;
1192 }
1193 }
1194
1195 return PRIMITIVES_SUCCESS;
1196}
1197
1198static inline pstatus_t general_RGBToYUV420_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1199 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1200 const UINT32 dstStep[3],
1201 const prim_size_t* WINPR_RESTRICT roi)
1202{
1203 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1204 size_t x1 = 0;
1205 size_t x2 = bpp;
1206 size_t x3 = srcStep;
1207 size_t x4 = srcStep + bpp;
1208 size_t y1 = 0;
1209 size_t y2 = 1;
1210 size_t y3 = dstStep[0];
1211 size_t y4 = dstStep[0] + 1;
1212 UINT32 max_x = roi->width - 1;
1213
1214 size_t y = 0;
1215 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1216 {
1217 const BYTE* src = pSrc + y * srcStep;
1218 BYTE* ydst = pDst[0] + y * dstStep[0];
1219 BYTE* udst = pDst[1] + i * dstStep[1];
1220 BYTE* vdst = pDst[2] + i * dstStep[2];
1221
1222 for (size_t x = 0; x < roi->width; x += 2)
1223 {
1224 BYTE R = 0;
1225 BYTE G = 0;
1226 BYTE B = 0;
1227 INT32 Ra = 0;
1228 INT32 Ga = 0;
1229 INT32 Ba = 0;
1230 UINT32 color = 0;
1231 /* row 1, pixel 1 */
1232 color = FreeRDPReadColor(src + x1, srcFormat);
1233 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1234 Ra = R;
1235 Ga = G;
1236 Ba = B;
1237 ydst[y1] = RGB2Y(R, G, B);
1238
1239 if (x < max_x)
1240 {
1241 /* row 1, pixel 2 */
1242 color = FreeRDPReadColor(src + x2, srcFormat);
1243 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1244 Ra += R;
1245 Ga += G;
1246 Ba += B;
1247 ydst[y2] = RGB2Y(R, G, B);
1248 }
1249
1250 /* row 2, pixel 1 */
1251 color = FreeRDPReadColor(src + x3, srcFormat);
1252 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1253 Ra += R;
1254 Ga += G;
1255 Ba += B;
1256 ydst[y3] = RGB2Y(R, G, B);
1257
1258 if (x < max_x)
1259 {
1260 /* row 2, pixel 2 */
1261 color = FreeRDPReadColor(src + x4, srcFormat);
1262 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1263 Ra += R;
1264 Ga += G;
1265 Ba += B;
1266 ydst[y4] = RGB2Y(R, G, B);
1267 }
1268
1269 Ra >>= 2;
1270 Ga >>= 2;
1271 Ba >>= 2;
1272 *udst++ = RGB2U(Ra, Ga, Ba);
1273 *vdst++ = RGB2V(Ra, Ga, Ba);
1274 ydst += 2;
1275 src += 2ULL * bpp;
1276 }
1277 }
1278
1279 for (; y < roi->height; y++)
1280 {
1281 const BYTE* src = pSrc + y * srcStep;
1282 BYTE* ydst = pDst[0] + y * dstStep[0];
1283 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1284 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1285
1286 for (size_t x = 0; x < roi->width; x += 2)
1287 {
1288 BYTE R = 0;
1289 BYTE G = 0;
1290 BYTE B = 0;
1291 /* row 1, pixel 1 */
1292 UINT32 color = FreeRDPReadColor(src + x1, srcFormat);
1293 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1294 INT32 Ra = R;
1295 INT32 Ga = G;
1296 INT32 Ba = B;
1297 ydst[y1] = RGB2Y(R, G, B);
1298
1299 if (x < max_x)
1300 {
1301 /* row 1, pixel 2 */
1302 color = FreeRDPReadColor(src + x2, srcFormat);
1303 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1304 Ra += R;
1305 Ga += G;
1306 Ba += B;
1307 ydst[y2] = RGB2Y(R, G, B);
1308 }
1309
1310 Ra >>= 2;
1311 Ga >>= 2;
1312 Ba >>= 2;
1313 *udst++ = RGB2U(Ra, Ga, Ba);
1314 *vdst++ = RGB2V(Ra, Ga, Ba);
1315 ydst += 2;
1316 src += 2ULL * bpp;
1317 }
1318 }
1319
1320 return PRIMITIVES_SUCCESS;
1321}
1322
1323static pstatus_t general_RGBToYUV420_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1324 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1325 const UINT32 dstStep[3],
1326 const prim_size_t* WINPR_RESTRICT roi)
1327{
1328 switch (srcFormat)
1329 {
1330 case PIXEL_FORMAT_BGRA32:
1331 case PIXEL_FORMAT_BGRX32:
1332 return general_RGBToYUV420_BGRX(pSrc, srcStep, pDst, dstStep, roi);
1333
1334 case PIXEL_FORMAT_RGBA32:
1335 case PIXEL_FORMAT_RGBX32:
1336 return general_RGBToYUV420_RGBX(pSrc, srcStep, pDst, dstStep, roi);
1337
1338 default:
1339 return general_RGBToYUV420_ANY(pSrc, srcFormat, srcStep, pDst, dstStep, roi);
1340 }
1341}
1342
1343static inline void int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
1344 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
1345 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1346 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1347 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1348{
1349 WINPR_ASSERT((width % 2) == 0);
1350 for (size_t x = offset; x < width; x += 2)
1351 {
1352 const BYTE* srcEven = &pSrcEven[4ULL * x];
1353 const BYTE* srcOdd = &pSrcOdd[4ULL * x];
1354 const BOOL lastX = (x + 1) >= width;
1355 BYTE Y1e = 0;
1356 BYTE Y2e = 0;
1357 BYTE U1e = 0;
1358 BYTE V1e = 0;
1359 BYTE U2e = 0;
1360 BYTE V2e = 0;
1361 BYTE Y1o = 0;
1362 BYTE Y2o = 0;
1363 BYTE U1o = 0;
1364 BYTE V1o = 0;
1365 BYTE U2o = 0;
1366 BYTE V2o = 0;
1367 /* Read 4 pixels, 2 from even, 2 from odd lines */
1368 {
1369 const BYTE b = *srcEven++;
1370 const BYTE g = *srcEven++;
1371 const BYTE r = *srcEven++;
1372 srcEven++;
1373 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1374 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1375 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1376 }
1377
1378 if (!lastX)
1379 {
1380 const BYTE b = *srcEven++;
1381 const BYTE g = *srcEven++;
1382 const BYTE r = *srcEven++;
1383 srcEven++;
1384 Y2e = RGB2Y(r, g, b);
1385 U2e = RGB2U(r, g, b);
1386 V2e = RGB2V(r, g, b);
1387 }
1388
1389 if (b1Odd)
1390 {
1391 const BYTE b = *srcOdd++;
1392 const BYTE g = *srcOdd++;
1393 const BYTE r = *srcOdd++;
1394 srcOdd++;
1395 Y1o = Y2o = RGB2Y(r, g, b);
1396 U1o = U2o = RGB2U(r, g, b);
1397 V1o = V2o = RGB2V(r, g, b);
1398 }
1399
1400 if (b1Odd && !lastX)
1401 {
1402 const BYTE b = *srcOdd++;
1403 const BYTE g = *srcOdd++;
1404 const BYTE r = *srcOdd++;
1405 srcOdd++;
1406 Y2o = RGB2Y(r, g, b);
1407 U2o = RGB2U(r, g, b);
1408 V2o = RGB2V(r, g, b);
1409 }
1410
1411 /* We have 4 Y pixels, so store them. */
1412 *b1Even++ = Y1e;
1413 *b1Even++ = Y2e;
1414
1415 if (b1Odd)
1416 {
1417 *b1Odd++ = Y1o;
1418 *b1Odd++ = Y2o;
1419 }
1420
1421 /* 2x 2y pixel in luma UV plane use averaging
1422 */
1423 {
1424 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1425 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1426 *b2++ = Uavg;
1427 *b3++ = Vavg;
1428 }
1429
1430 /* UV from 2x, 2y+1 */
1431 if (b1Odd)
1432 {
1433 *b4++ = U1o;
1434 *b5++ = V1o;
1435
1436 if (!lastX)
1437 {
1438 *b4++ = U2o;
1439 *b5++ = V2o;
1440 }
1441 }
1442
1443 /* UV from 2x+1, 2y */
1444 if (!lastX)
1445 {
1446 *b6++ = U2e;
1447 *b7++ = V2e;
1448 }
1449 }
1450}
1451
1452void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(size_t offset, const BYTE* WINPR_RESTRICT pSrcEven,
1453 const BYTE* WINPR_RESTRICT pSrcOdd,
1454 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd,
1455 BYTE* WINPR_RESTRICT b2, BYTE* WINPR_RESTRICT b3,
1456 BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1457 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7,
1458 UINT32 width)
1459{
1460 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(offset, pSrcEven, pSrcOdd, b1Even, b1Odd, b2, b3, b4,
1461 b5, b6, b7, width);
1462}
1463
1464static inline pstatus_t general_RGBToAVC444YUV_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1465 BYTE* WINPR_RESTRICT pDst1[3],
1466 const UINT32 dst1Step[3],
1467 BYTE* WINPR_RESTRICT pDst2[3],
1468 const UINT32 dst2Step[3],
1469 const prim_size_t* WINPR_RESTRICT roi)
1470{
1475 size_t y = 0;
1476 for (; y < roi->height - roi->height % 2; y += 2)
1477 {
1478 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1479 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1480 const size_t i = y >> 1;
1481 const size_t n = (i & (uint32_t)~7) + i;
1482 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1483 BYTE* b1Odd = (b1Even + dst1Step[0]);
1484 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1485 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1486 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1487 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1488 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1489 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1490 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4,
1491 b5, b6, b7, roi->width);
1492 }
1493 for (; y < roi->height; y++)
1494 {
1495 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1496 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1497 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1498 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1499 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1500 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1501 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, nullptr, b1Even, nullptr, b2, b3,
1502 nullptr, nullptr, b6, b7, roi->width);
1503 }
1504
1505 return PRIMITIVES_SUCCESS;
1506}
1507
1508static inline void general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(
1509 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
1510 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1511 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1512 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1513{
1514 WINPR_ASSERT((width % 2) == 0);
1515 for (UINT32 x = 0; x < width; x += 2)
1516 {
1517 const BOOL lastX = (x + 1) >= width;
1518 BYTE Y1e = 0;
1519 BYTE Y2e = 0;
1520 BYTE U1e = 0;
1521 BYTE V1e = 0;
1522 BYTE U2e = 0;
1523 BYTE V2e = 0;
1524 BYTE Y1o = 0;
1525 BYTE Y2o = 0;
1526 BYTE U1o = 0;
1527 BYTE V1o = 0;
1528 BYTE U2o = 0;
1529 BYTE V2o = 0;
1530 /* Read 4 pixels, 2 from even, 2 from odd lines */
1531 {
1532 const BYTE r = *srcEven++;
1533 const BYTE g = *srcEven++;
1534 const BYTE b = *srcEven++;
1535 srcEven++;
1536 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1537 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1538 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1539 }
1540
1541 if (!lastX)
1542 {
1543 const BYTE r = *srcEven++;
1544 const BYTE g = *srcEven++;
1545 const BYTE b = *srcEven++;
1546 srcEven++;
1547 Y2e = RGB2Y(r, g, b);
1548 U2e = RGB2U(r, g, b);
1549 V2e = RGB2V(r, g, b);
1550 }
1551
1552 if (b1Odd)
1553 {
1554 const BYTE r = *srcOdd++;
1555 const BYTE g = *srcOdd++;
1556 const BYTE b = *srcOdd++;
1557 srcOdd++;
1558 Y1o = Y2o = RGB2Y(r, g, b);
1559 U1o = U2o = RGB2U(r, g, b);
1560 V1o = V2o = RGB2V(r, g, b);
1561 }
1562
1563 if (b1Odd && !lastX)
1564 {
1565 const BYTE r = *srcOdd++;
1566 const BYTE g = *srcOdd++;
1567 const BYTE b = *srcOdd++;
1568 srcOdd++;
1569 Y2o = RGB2Y(r, g, b);
1570 U2o = RGB2U(r, g, b);
1571 V2o = RGB2V(r, g, b);
1572 }
1573
1574 /* We have 4 Y pixels, so store them. */
1575 *b1Even++ = Y1e;
1576 *b1Even++ = Y2e;
1577
1578 if (b1Odd)
1579 {
1580 *b1Odd++ = Y1o;
1581 *b1Odd++ = Y2o;
1582 }
1583
1584 /* 2x 2y pixel in luma UV plane use averaging
1585 */
1586 {
1587 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1588 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1589 *b2++ = Uavg;
1590 *b3++ = Vavg;
1591 }
1592
1593 /* UV from 2x, 2y+1 */
1594 if (b1Odd)
1595 {
1596 *b4++ = U1o;
1597 *b5++ = V1o;
1598
1599 if (!lastX)
1600 {
1601 *b4++ = U2o;
1602 *b5++ = V2o;
1603 }
1604 }
1605
1606 /* UV from 2x+1, 2y */
1607 if (!lastX)
1608 {
1609 *b6++ = U2e;
1610 *b7++ = V2e;
1611 }
1612 }
1613}
1614
1615static inline pstatus_t general_RGBToAVC444YUV_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1616 BYTE* WINPR_RESTRICT pDst1[3],
1617 const UINT32 dst1Step[3],
1618 BYTE* WINPR_RESTRICT pDst2[3],
1619 const UINT32 dst2Step[3],
1620 const prim_size_t* WINPR_RESTRICT roi)
1621{
1627 size_t y = 0;
1628 for (; y < roi->height - roi->height % 2; y += 2)
1629 {
1630 const BOOL last = (y >= (roi->height - 1));
1631 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1632 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1633 const size_t i = y >> 1;
1634 const size_t n = (i & (size_t)~7) + i;
1635 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1636 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : nullptr;
1637 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1638 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1639 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1640 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1641 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1642 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1643 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5, b6,
1644 b7, roi->width);
1645 }
1646 for (; y < roi->height; y++)
1647 {
1648 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1649 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1650 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1651 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1652 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1653 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1654 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, nullptr, b1Even, nullptr, b2, b3, nullptr,
1655 nullptr, b6, b7, roi->width);
1656 }
1657 return PRIMITIVES_SUCCESS;
1658}
1659
1660static inline void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(
1661 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1662 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1663 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1664 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1665{
1666 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1667 for (UINT32 x = 0; x < width; x += 2)
1668 {
1669 const BOOL lastX = (x + 1) >= width;
1670 BYTE Y1e = 0;
1671 BYTE Y2e = 0;
1672 BYTE U1e = 0;
1673 BYTE V1e = 0;
1674 BYTE U2e = 0;
1675 BYTE V2e = 0;
1676 BYTE Y1o = 0;
1677 BYTE Y2o = 0;
1678 BYTE U1o = 0;
1679 BYTE V1o = 0;
1680 BYTE U2o = 0;
1681 BYTE V2o = 0;
1682 /* Read 4 pixels, 2 from even, 2 from odd lines */
1683 {
1684 BYTE r = 0;
1685 BYTE g = 0;
1686 BYTE b = 0;
1687 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1688 srcEven += bpp;
1689 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1690 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1691 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1692 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1693 }
1694
1695 if (!lastX)
1696 {
1697 BYTE r = 0;
1698 BYTE g = 0;
1699 BYTE b = 0;
1700 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1701 srcEven += bpp;
1702 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1703 Y2e = RGB2Y(r, g, b);
1704 U2e = RGB2U(r, g, b);
1705 V2e = RGB2V(r, g, b);
1706 }
1707
1708 if (b1Odd)
1709 {
1710 BYTE r = 0;
1711 BYTE g = 0;
1712 BYTE b = 0;
1713 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1714 srcOdd += bpp;
1715 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1716 Y1o = Y2o = RGB2Y(r, g, b);
1717 U1o = U2o = RGB2U(r, g, b);
1718 V1o = V2o = RGB2V(r, g, b);
1719 }
1720
1721 if (b1Odd && !lastX)
1722 {
1723 BYTE r = 0;
1724 BYTE g = 0;
1725 BYTE b = 0;
1726 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1727 srcOdd += bpp;
1728 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1729 Y2o = RGB2Y(r, g, b);
1730 U2o = RGB2U(r, g, b);
1731 V2o = RGB2V(r, g, b);
1732 }
1733
1734 /* We have 4 Y pixels, so store them. */
1735 *b1Even++ = Y1e;
1736 *b1Even++ = Y2e;
1737
1738 if (b1Odd)
1739 {
1740 *b1Odd++ = Y1o;
1741 *b1Odd++ = Y2o;
1742 }
1743
1744 /* 2x 2y pixel in luma UV plane use averaging
1745 */
1746 {
1747 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(
1748 BYTE, ((UINT16)U1e + (UINT16)U2e + (UINT16)U1o + (UINT16)U2o) / 4);
1749 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(
1750 BYTE, ((UINT16)V1e + (UINT16)V2e + (UINT16)V1o + (UINT16)V2o) / 4);
1751 *b2++ = Uavg;
1752 *b3++ = Vavg;
1753 }
1754
1755 /* UV from 2x, 2y+1 */
1756 if (b1Odd)
1757 {
1758 *b4++ = U1o;
1759 *b5++ = V1o;
1760
1761 if (!lastX)
1762 {
1763 *b4++ = U2o;
1764 *b5++ = V2o;
1765 }
1766 }
1767
1768 /* UV from 2x+1, 2y */
1769 if (!lastX)
1770 {
1771 *b6++ = U2e;
1772 *b7++ = V2e;
1773 }
1774 }
1775}
1776
1777static inline pstatus_t
1778general_RGBToAVC444YUV_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
1779 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
1780 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
1781 const prim_size_t* WINPR_RESTRICT roi)
1782{
1840 const BYTE* pMaxSrc = pSrc + 1ULL * (roi->height - 1) * srcStep;
1841
1842 for (size_t y = 0; y < roi->height; y += 2)
1843 {
1844 WINPR_ASSERT(y < UINT32_MAX);
1845
1846 const BOOL last = (y >= (roi->height - 1));
1847 const BYTE* srcEven = y < roi->height ? pSrc + y * srcStep : pMaxSrc;
1848 const BYTE* srcOdd = !last ? pSrc + (y + 1) * srcStep : pMaxSrc;
1849 const UINT32 i = (UINT32)y >> 1;
1850 const UINT32 n = (i & (uint32_t)~7) + i;
1851 BYTE* b1Even = pDst1[0] + y * dst1Step[0];
1852 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : nullptr;
1853 BYTE* b2 = pDst1[1] + (y / 2) * dst1Step[1];
1854 BYTE* b3 = pDst1[2] + (y / 2) * dst1Step[2];
1855 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1856 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1857 BYTE* b6 = pDst2[1] + (y / 2) * dst2Step[1];
1858 BYTE* b7 = pDst2[2] + (y / 2) * dst2Step[2];
1859 general_RGBToAVC444YUV_ANY_DOUBLE_ROW(srcEven, srcOdd, srcFormat, b1Even, b1Odd, b2, b3, b4,
1860 b5, b6, b7, roi->width);
1861 }
1862
1863 return PRIMITIVES_SUCCESS;
1864}
1865
1866static inline pstatus_t general_RGBToAVC444YUV(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1867 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
1868 const UINT32 dst1Step[3],
1869 BYTE* WINPR_RESTRICT pDst2[3],
1870 const UINT32 dst2Step[3],
1871 const prim_size_t* WINPR_RESTRICT roi)
1872{
1873 if (!pSrc || !pDst1 || !dst1Step || !pDst2 || !dst2Step)
1874 return -1;
1875
1876 if (!pDst1[0] || !pDst1[1] || !pDst1[2])
1877 return -1;
1878
1879 if (!dst1Step[0] || !dst1Step[1] || !dst1Step[2])
1880 return -1;
1881
1882 if (!pDst2[0] || !pDst2[1] || !pDst2[2])
1883 return -1;
1884
1885 if (!dst2Step[0] || !dst2Step[1] || !dst2Step[2])
1886 return -1;
1887
1888 switch (srcFormat)
1889 {
1890
1891 case PIXEL_FORMAT_BGRA32:
1892 case PIXEL_FORMAT_BGRX32:
1893 return general_RGBToAVC444YUV_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1894 roi);
1895
1896 case PIXEL_FORMAT_RGBA32:
1897 case PIXEL_FORMAT_RGBX32:
1898 return general_RGBToAVC444YUV_RGBX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1899 roi);
1900
1901 default:
1902 return general_RGBToAVC444YUV_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
1903 dst2Step, roi);
1904 }
1905
1906 return !PRIMITIVES_SUCCESS;
1907}
1908
1909static inline void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
1910 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1911 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
1912 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
1913 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
1914 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
1915 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
1916 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
1917{
1918 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1919
1920 WINPR_ASSERT((width % 2) == 0);
1921 for (UINT32 x = 0; x < width; x += 2)
1922 {
1923 BYTE Ya = 0;
1924 BYTE Ua = 0;
1925 BYTE Va = 0;
1926 BYTE Yb = 0;
1927 BYTE Ub = 0;
1928 BYTE Vb = 0;
1929 BYTE Yc = 0;
1930 BYTE Uc = 0;
1931 BYTE Vc = 0;
1932 BYTE Yd = 0;
1933 BYTE Ud = 0;
1934 BYTE Vd = 0;
1935 {
1936 BYTE b = 0;
1937 BYTE g = 0;
1938 BYTE r = 0;
1939 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1940 srcEven += bpp;
1941 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1942 Ya = RGB2Y(r, g, b);
1943 Ua = RGB2U(r, g, b);
1944 Va = RGB2V(r, g, b);
1945 }
1946
1947 if (x < width - 1)
1948 {
1949 BYTE b = 0;
1950 BYTE g = 0;
1951 BYTE r = 0;
1952 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1953 srcEven += bpp;
1954 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1955 Yb = RGB2Y(r, g, b);
1956 Ub = RGB2U(r, g, b);
1957 Vb = RGB2V(r, g, b);
1958 }
1959 else
1960 {
1961 Yb = Ya;
1962 Ub = Ua;
1963 Vb = Va;
1964 }
1965
1966 if (srcOdd)
1967 {
1968 BYTE b = 0;
1969 BYTE g = 0;
1970 BYTE r = 0;
1971 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1972 srcOdd += bpp;
1973 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1974 Yc = RGB2Y(r, g, b);
1975 Uc = RGB2U(r, g, b);
1976 Vc = RGB2V(r, g, b);
1977 }
1978 else
1979 {
1980 Yc = Ya;
1981 Uc = Ua;
1982 Vc = Va;
1983 }
1984
1985 if (srcOdd && (x < width - 1))
1986 {
1987 BYTE b = 0;
1988 BYTE g = 0;
1989 BYTE r = 0;
1990 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1991 srcOdd += bpp;
1992 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1993 Yd = RGB2Y(r, g, b);
1994 Ud = RGB2U(r, g, b);
1995 Vd = RGB2V(r, g, b);
1996 }
1997 else
1998 {
1999 Yd = Ya;
2000 Ud = Ua;
2001 Vd = Va;
2002 }
2003
2004 /* Y [b1] */
2005 *yLumaDstEven++ = Ya;
2006
2007 if (x < width - 1)
2008 *yLumaDstEven++ = Yb;
2009
2010 if (srcOdd)
2011 *yLumaDstOdd++ = Yc;
2012
2013 if (srcOdd && (x < width - 1))
2014 *yLumaDstOdd++ = Yd;
2015
2016 /* 2x 2y [b2,b3] */
2017 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2018 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2019
2020 /* 2x+1, y [b4,b5] even */
2021 if (x < width - 1)
2022 {
2023 *yEvenChromaDst1++ = Ub;
2024 *yEvenChromaDst2++ = Vb;
2025 }
2026
2027 if (srcOdd)
2028 {
2029 /* 2x+1, y [b4,b5] odd */
2030 if (x < width - 1)
2031 {
2032 *yOddChromaDst1++ = Ud;
2033 *yOddChromaDst2++ = Vd;
2034 }
2035
2036 /* 4x 2y+1 [b6, b7] */
2037 if (x % 4 == 0)
2038 {
2039 *uChromaDst1++ = Uc;
2040 *uChromaDst2++ = Vc;
2041 }
2042 /* 4x+2 2y+1 [b8, b9] */
2043 else
2044 {
2045 *vChromaDst1++ = Uc;
2046 *vChromaDst2++ = Vc;
2047 }
2048 }
2049 }
2050}
2051
2052static inline pstatus_t
2053general_RGBToAVC444YUVv2_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
2054 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
2055 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
2056 const prim_size_t* WINPR_RESTRICT roi)
2057{
2108 if (roi->height < 1 || roi->width < 1)
2109 return !PRIMITIVES_SUCCESS;
2110
2111 size_t y = 0;
2112 for (; y < roi->height - roi->height % 2; y += 2)
2113 {
2114 const BYTE* srcEven = (pSrc + y * srcStep);
2115 const BYTE* srcOdd = (y < roi->height - 1) ? (srcEven + srcStep) : nullptr;
2116 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2117 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2118 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2119 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2120 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2121 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2122 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2123 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2124 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2125 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2126 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2127 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2128 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2129 srcEven, srcOdd, srcFormat, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV,
2130 dstEvenChromaY1, dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1,
2131 dstChromaU2, dstChromaV1, dstChromaV2, roi->width);
2132 }
2133 for (; y < roi->height; y++)
2134 {
2135 const BYTE* srcEven = (pSrc + y * srcStep);
2136 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2137 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2138 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2139 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2140 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2141 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2142 srcEven, nullptr, srcFormat, dstLumaYEven, nullptr, dstLumaU, dstLumaV, dstEvenChromaY1,
2143 dstEvenChromaY2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, roi->width);
2144 }
2145
2146 return PRIMITIVES_SUCCESS;
2147}
2148
2149static inline void int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2150 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2151 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2152 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2153 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2154 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2155 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2156 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2157{
2158 WINPR_ASSERT((width % 2) == 0);
2159 WINPR_ASSERT(pSrcEven);
2160 WINPR_ASSERT(yLumaDstEven);
2161 WINPR_ASSERT(uLumaDst);
2162 WINPR_ASSERT(vLumaDst);
2163
2164 for (size_t x = offset; x < width; x += 2)
2165 {
2166 const BYTE* srcEven = &pSrcEven[4ULL * x];
2167 const BYTE* srcOdd = pSrcOdd ? &pSrcOdd[4ULL * x] : nullptr;
2168 BYTE Ya = 0;
2169 BYTE Ua = 0;
2170 BYTE Va = 0;
2171 BYTE Yb = 0;
2172 BYTE Ub = 0;
2173 BYTE Vb = 0;
2174 BYTE Yc = 0;
2175 BYTE Uc = 0;
2176 BYTE Vc = 0;
2177 BYTE Yd = 0;
2178 BYTE Ud = 0;
2179 BYTE Vd = 0;
2180 {
2181 const BYTE b = *srcEven++;
2182 const BYTE g = *srcEven++;
2183 const BYTE r = *srcEven++;
2184 srcEven++;
2185 Ya = RGB2Y(r, g, b);
2186 Ua = RGB2U(r, g, b);
2187 Va = RGB2V(r, g, b);
2188 }
2189
2190 if (x < width - 1)
2191 {
2192 const BYTE b = *srcEven++;
2193 const BYTE g = *srcEven++;
2194 const BYTE r = *srcEven++;
2195 srcEven++;
2196 Yb = RGB2Y(r, g, b);
2197 Ub = RGB2U(r, g, b);
2198 Vb = RGB2V(r, g, b);
2199 }
2200 else
2201 {
2202 Yb = Ya;
2203 Ub = Ua;
2204 Vb = Va;
2205 }
2206
2207 if (srcOdd)
2208 {
2209 const BYTE b = *srcOdd++;
2210 const BYTE g = *srcOdd++;
2211 const BYTE r = *srcOdd++;
2212 srcOdd++;
2213 Yc = RGB2Y(r, g, b);
2214 Uc = RGB2U(r, g, b);
2215 Vc = RGB2V(r, g, b);
2216 }
2217 else
2218 {
2219 Yc = Ya;
2220 Uc = Ua;
2221 Vc = Va;
2222 }
2223
2224 if (srcOdd && (x < width - 1))
2225 {
2226 const BYTE b = *srcOdd++;
2227 const BYTE g = *srcOdd++;
2228 const BYTE r = *srcOdd++;
2229 srcOdd++;
2230 Yd = RGB2Y(r, g, b);
2231 Ud = RGB2U(r, g, b);
2232 Vd = RGB2V(r, g, b);
2233 }
2234 else
2235 {
2236 Yd = Ya;
2237 Ud = Ua;
2238 Vd = Va;
2239 }
2240
2241 /* Y [b1] */
2242 *yLumaDstEven++ = Ya;
2243
2244 if (x < width - 1)
2245 *yLumaDstEven++ = Yb;
2246
2247 if (srcOdd && yLumaDstOdd)
2248 *yLumaDstOdd++ = Yc;
2249
2250 if (srcOdd && (x < width - 1) && yLumaDstOdd)
2251 *yLumaDstOdd++ = Yd;
2252
2253 /* 2x 2y [b2,b3] */
2254 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2255 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2256
2257 /* 2x+1, y [b4,b5] even */
2258 if (x < width - 1)
2259 {
2260 *yEvenChromaDst1++ = Ub;
2261 *yEvenChromaDst2++ = Vb;
2262 }
2263
2264 if (srcOdd)
2265 {
2266 /* 2x+1, y [b4,b5] odd */
2267 if (x < width - 1)
2268 {
2269 *yOddChromaDst1++ = Ud;
2270 *yOddChromaDst2++ = Vd;
2271 }
2272
2273 /* 4x 2y+1 [b6, b7] */
2274 if (x % 4 == 0)
2275 {
2276 *uChromaDst1++ = Uc;
2277 *uChromaDst2++ = Vc;
2278 }
2279 /* 4x+2 2y+1 [b8, b9] */
2280 else
2281 {
2282 *vChromaDst1++ = Uc;
2283 *vChromaDst2++ = Vc;
2284 }
2285 }
2286 }
2287}
2288
2289void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2290 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2291 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2292 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2293 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2294 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2295 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2296 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2297{
2298 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2299 offset, pSrcEven, pSrcOdd, yLumaDstEven, yLumaDstOdd, uLumaDst, vLumaDst, yEvenChromaDst1,
2300 yEvenChromaDst2, yOddChromaDst1, yOddChromaDst2, uChromaDst1, uChromaDst2, vChromaDst1,
2301 vChromaDst2, width);
2302}
2303
2304static inline pstatus_t general_RGBToAVC444YUVv2_BGRX(const BYTE* WINPR_RESTRICT pSrc,
2305 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2306 const UINT32 dst1Step[3],
2307 BYTE* WINPR_RESTRICT pDst2[3],
2308 const UINT32 dst2Step[3],
2309 const prim_size_t* WINPR_RESTRICT roi)
2310{
2311 if (roi->height < 1 || roi->width < 1)
2312 return !PRIMITIVES_SUCCESS;
2313
2314 size_t y = 0;
2315 for (; y < roi->height - roi->height % 2; y += 2)
2316 {
2317 const BYTE* srcEven = (pSrc + y * srcStep);
2318 const BYTE* srcOdd = (srcEven + srcStep);
2319 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2320 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2321 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2322 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2323 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2324 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2325 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2326 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2327 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2328 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2329 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2330 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2331 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2332 0, srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
2333 dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1, dstChromaU2, dstChromaV1,
2334 dstChromaV2, roi->width);
2335 }
2336 for (; y < roi->height; y++)
2337 {
2338 const BYTE* srcEven = (pSrc + y * srcStep);
2339 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2340 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2341 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2342 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2343 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2344 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2345 0, srcEven, nullptr, dstLumaYEven, nullptr, dstLumaU, dstLumaV, dstEvenChromaY1,
2346 dstEvenChromaY2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, roi->width);
2347 }
2348
2349 return PRIMITIVES_SUCCESS;
2350}
2351
2352static pstatus_t general_RGBToAVC444YUVv2(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
2353 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2354 const UINT32 dst1Step[3], BYTE* WINPR_RESTRICT pDst2[3],
2355 const UINT32 dst2Step[3],
2356 const prim_size_t* WINPR_RESTRICT roi)
2357{
2358 switch (srcFormat)
2359 {
2360 case PIXEL_FORMAT_BGRA32:
2361 case PIXEL_FORMAT_BGRX32:
2362 return general_RGBToAVC444YUVv2_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
2363 roi);
2364
2365 default:
2366 return general_RGBToAVC444YUVv2_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
2367 dst2Step, roi);
2368 }
2369
2370 return !PRIMITIVES_SUCCESS;
2371}
2372
2373void primitives_init_YUV(primitives_t* WINPR_RESTRICT prims)
2374{
2375 prims->YUV420ToRGB_8u_P3AC4R = general_YUV420ToRGB_8u_P3AC4R;
2376 prims->YUV444ToRGB_8u_P3AC4R = general_YUV444ToRGB_8u_P3AC4R;
2377 prims->RGBToYUV420_8u_P3AC4R = general_RGBToYUV420_8u_P3AC4R;
2378 prims->RGBToYUV444_8u_P3AC4R = general_RGBToYUV444_8u_P3AC4R;
2379 prims->RGBToI444_8u = general_RGBToI444_8u;
2380 prims->YUV420CombineToYUV444 = general_YUV420CombineToYUV444;
2381 prims->YUV444SplitToYUV420 = general_YUV444SplitToYUV420;
2382 prims->RGBToAVC444YUV = general_RGBToAVC444YUV;
2383 prims->RGBToAVC444YUVv2 = general_RGBToAVC444YUVv2;
2384}
2385
2386void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims)
2387{
2388 primitives_init_YUV(prims);
2389 primitives_init_YUV_sse41(prims);
2390 primitives_init_YUV_neon(prims);
2391}
RECTANGLE_16
Definition types.h:109
prim_size_t
Definition primitives.h:74
primitives_t
Definition primitives.h:255