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 padHeight = 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 < padHeight; 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 if (y < nHeight)
150 memcpy(pX, Ya, nWidth);
151 }
152
153 /* B6 and B7 */
154 for (UINT32 y = 0; y < halfHeight; y++)
155 {
156 const UINT32 val2y = (y * 2UL + evenY);
157 const BYTE* Ua = pSrc[1] + 1ULL * y * srcStep[1];
158 const BYTE* Va = pSrc[2] + 1ULL * y * srcStep[2];
159 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;
160 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;
161
162 for (UINT32 x = 0; x < halfWidth; x++)
163 {
164 const UINT32 val2x1 = (x * 2 + oddX);
165 pU[val2x1] = Ua[x];
166 pV[val2x1] = Va[x];
167 }
168 }
169
170 return PRIMITIVES_SUCCESS;
171}
172
173static inline pstatus_t general_ChromaV2ToYUV444(const BYTE* WINPR_RESTRICT pSrc[3],
174 const UINT32 srcStep[3], UINT32 nTotalWidth,
175 WINPR_ATTR_UNUSED UINT32 nTotalHeight,
176 BYTE* WINPR_RESTRICT pDst[3],
177 const UINT32 dstStep[3],
178 const RECTANGLE_16* WINPR_RESTRICT roi)
179{
180 const UINT32 nWidth = roi->right - roi->left;
181 const UINT32 nHeight = roi->bottom - roi->top;
182 const UINT32 halfWidth = (nWidth + 1) / 2;
183 const UINT32 halfHeight = (nHeight + 1) / 2;
184 const UINT32 quaterWidth = (nWidth + 3) / 4;
185
186 /* B4 and B5: odd UV values for width/2, height */
187 for (UINT32 y = 0; y < nHeight; y++)
188 {
189 const UINT32 yTop = y + roi->top;
190 const BYTE* pYaU = pSrc[0] + 1ULL * srcStep[0] * yTop + roi->left / 2;
191 const BYTE* pYaV = pYaU + nTotalWidth / 2;
192 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * yTop + roi->left;
193 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * yTop + roi->left;
194
195 for (UINT32 x = 0; x < halfWidth; x++)
196 {
197 const UINT32 odd = 2UL * x + 1UL;
198 pU[odd] = *pYaU++;
199 pV[odd] = *pYaV++;
200 }
201 }
202
203 /* B6 - B9 */
204 for (size_t y = 0; y < halfHeight; y++)
205 {
206 const BYTE* pUaU = pSrc[1] + srcStep[1] * (y + roi->top / 2) + roi->left / 4;
207 const BYTE* pUaV = pUaU + nTotalWidth / 4;
208 const BYTE* pVaU = pSrc[2] + srcStep[2] * (y + roi->top / 2) + roi->left / 4;
209 const BYTE* pVaV = pVaU + nTotalWidth / 4;
210 BYTE* pU = pDst[1] + 1ULL * dstStep[1] * (2ULL * y + 1 + roi->top) + roi->left;
211 BYTE* pV = pDst[2] + 1ULL * dstStep[2] * (2ULL * y + 1 + roi->top) + roi->left;
212
213 for (size_t x = 0; x < quaterWidth; x++)
214 {
215 pU[4 * x + 0] = *pUaU++;
216 pV[4 * x + 0] = *pUaV++;
217 pU[4 * x + 2] = *pVaU++;
218 pV[4 * x + 2] = *pVaV++;
219 }
220 }
221
222 return PRIMITIVES_SUCCESS;
223}
224
225static pstatus_t general_YUV420CombineToYUV444(avc444_frame_type type,
226 const BYTE* WINPR_RESTRICT pSrc[3],
227 const UINT32 srcStep[3], UINT32 nWidth,
228 UINT32 nHeight, BYTE* WINPR_RESTRICT pDst[3],
229 const UINT32 dstStep[3],
230 const RECTANGLE_16* WINPR_RESTRICT roi)
231{
232 if (!pSrc || !pSrc[0] || !pSrc[1] || !pSrc[2])
233 return -1;
234
235 if (!pDst || !pDst[0] || !pDst[1] || !pDst[2])
236 return -1;
237
238 if (!roi)
239 return -1;
240
241 switch (type)
242 {
243 case AVC444_LUMA:
244 return general_LumaToYUV444(pSrc, srcStep, pDst, dstStep, roi);
245
246 case AVC444_CHROMAv1:
247 return general_ChromaV1ToYUV444(pSrc, srcStep, pDst, dstStep, roi);
248
249 case AVC444_CHROMAv2:
250 return general_ChromaV2ToYUV444(pSrc, srcStep, nWidth, nHeight, pDst, dstStep, roi);
251
252 default:
253 return -1;
254 }
255}
256
257static pstatus_t
258general_YUV444SplitToYUV420(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
259 BYTE* WINPR_RESTRICT pMainDst[3], const UINT32 dstMainStep[3],
260 BYTE* WINPR_RESTRICT pAuxDst[3], const UINT32 dstAuxStep[3],
261 const prim_size_t* WINPR_RESTRICT roi)
262{
263 UINT32 uY = 0;
264 UINT32 vY = 0;
265
266 /* The auxiliary frame is aligned to multiples of 16x16.
267 * We need the padded height for B4 and B5 conversion. */
268 const UINT32 padHeight = roi->height + 16 - roi->height % 16;
269 const UINT32 halfWidth = (roi->width + 1) / 2;
270 const UINT32 halfHeight = (roi->height + 1) / 2;
271
272 /* B1 */
273 for (size_t y = 0; y < roi->height; y++)
274 {
275 const BYTE* pSrcY = pSrc[0] + y * srcStep[0];
276 BYTE* pY = pMainDst[0] + y * dstMainStep[0];
277 memcpy(pY, pSrcY, roi->width);
278 }
279
280 /* B2 and B3 */
281 for (size_t y = 0; y < halfHeight; y++)
282 {
283 const BYTE* pSrcU = pSrc[1] + 2ULL * y * srcStep[1];
284 const BYTE* pSrcV = pSrc[2] + 2ULL * y * srcStep[2];
285 BYTE* pU = pMainDst[1] + y * dstMainStep[1];
286 BYTE* pV = pMainDst[2] + y * dstMainStep[2];
287
288 for (size_t x = 0; x < halfWidth; x++)
289 {
290 pU[x] = pSrcV[2 * x];
291 pV[x] = pSrcU[2 * x];
292 }
293 }
294
295 /* B4 and B5 */
296 for (size_t y = 0; y < padHeight; y++)
297 {
298 BYTE* pY = pAuxDst[0] + y * dstAuxStep[0];
299
300 if (y % 16 < 8)
301 {
302 const size_t pos = (2 * uY++ + 1);
303 const BYTE* pSrcU = pSrc[1] + pos * srcStep[1];
304
305 if (pos >= roi->height)
306 continue;
307
308 memcpy(pY, pSrcU, roi->width);
309 }
310 else
311 {
312 const size_t pos = (2 * vY++ + 1);
313 const BYTE* pSrcV = pSrc[2] + pos * srcStep[2];
314
315 if (pos >= roi->height)
316 continue;
317
318 memcpy(pY, pSrcV, roi->width);
319 }
320 }
321
322 /* B6 and B7 */
323 for (size_t y = 0; y < halfHeight; y++)
324 {
325 const BYTE* pSrcU = pSrc[1] + 2 * y * srcStep[1];
326 const BYTE* pSrcV = pSrc[2] + 2 * y * srcStep[2];
327 BYTE* pU = pAuxDst[1] + y * dstAuxStep[1];
328 BYTE* pV = pAuxDst[2] + y * dstAuxStep[2];
329
330 for (size_t x = 0; x < halfWidth; x++)
331 {
332 pU[x] = pSrcU[2 * x + 1];
333 pV[x] = pSrcV[2 * x + 1];
334 }
335 }
336
337 return PRIMITIVES_SUCCESS;
338}
339
340static inline void general_YUV444ToRGB_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
341 const BYTE* WINPR_RESTRICT pY[2],
342 const BYTE* WINPR_RESTRICT pU[2],
343 const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
344{
345 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
346
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 for (size_t x = 0; x < nWidth; x += 2)
380 {
381 for (size_t j = 0; j < 2; j++)
382 {
383 const BYTE y = pY[x + j];
384 const BYTE u = pU[x + j];
385 const BYTE v = pV[x + j];
386 pRGB = writeYUVPixel(pRGB, DstFormat, y, u, v, writePixel);
387 }
388 }
389}
390
391static inline pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* WINPR_RESTRICT pSrc[3],
392 const UINT32 srcStep[3],
393 BYTE* WINPR_RESTRICT pDst,
394 UINT32 dstStep, UINT32 DstFormat,
395 const prim_size_t* WINPR_RESTRICT roi)
396{
397 WINPR_ASSERT(pSrc);
398 WINPR_ASSERT(pDst);
399 WINPR_ASSERT(roi);
400
401 const UINT32 nWidth = roi->width;
402 const UINT32 nHeight = roi->height;
403
404 size_t y = 0;
405 for (; y < nHeight - nHeight % 2; y += 2)
406 {
407 const BYTE* WINPR_RESTRICT pY[2] = { pSrc[0] + y * srcStep[0],
408 pSrc[0] + (y + 1) * srcStep[0] };
409 const BYTE* WINPR_RESTRICT pU[2] = { pSrc[1] + y * srcStep[1],
410 pSrc[1] + (y + 1) * srcStep[1] };
411 const BYTE* WINPR_RESTRICT pV[2] = { pSrc[2] + y * srcStep[2],
412 pSrc[2] + (y + 1) * srcStep[2] };
413 BYTE* WINPR_RESTRICT pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
414
415 general_YUV444ToRGB_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
416 }
417 for (; y < nHeight; y++)
418 {
419 const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
420 const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
421 const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
422 BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
423
424 general_YUV444ToRGB_SINGLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
425 }
426
427 return PRIMITIVES_SUCCESS;
428}
429
430static inline void general_YUV444ToBGRX_DOUBLE_ROW(BYTE* WINPR_RESTRICT pRGB[2], UINT32 DstFormat,
431 const BYTE* WINPR_RESTRICT pY[2],
432 const BYTE* WINPR_RESTRICT pU[2],
433 const BYTE* WINPR_RESTRICT pV[2], size_t nWidth)
434{
435 WINPR_ASSERT(nWidth % 2 == 0);
436 for (size_t x = 0; x < nWidth; x += 2)
437 {
438 const INT32 subU = pU[0][x + 1] + pU[1][x] + pU[1][x + 1];
439 const INT32 avgU = ((4 * pU[0][x]) - subU);
440 const BYTE useU = CONDITIONAL_CLIP(avgU, pU[0][x]);
441 const INT32 subV = pV[0][x + 1] + pV[1][x] + pV[1][x + 1];
442 const INT32 avgV = ((4 * pV[0][x]) - subV);
443 const BYTE useV = CONDITIONAL_CLIP(avgV, pV[0][x]);
444
445 const BYTE U[2][2] = { { useU, pU[0][x + 1] }, { pU[1][x], pU[1][x + 1] } };
446 const BYTE V[2][2] = { { useV, pV[0][x + 1] }, { pV[1][x], pV[1][x + 1] } };
447
448 for (size_t i = 0; i < 2; i++)
449 {
450 for (size_t j = 0; j < 2; j++)
451 {
452 const BYTE y = pY[i][x + j];
453 const BYTE u = U[i][j];
454 const BYTE v = V[i][j];
455 pRGB[i] = writeYUVPixel(pRGB[i], DstFormat, y, u, v, writePixelBGRX);
456 }
457 }
458 }
459}
460
461static inline void general_YUV444ToBGRX_SINGLE_ROW(BYTE* WINPR_RESTRICT pRGB, UINT32 DstFormat,
462 const BYTE* WINPR_RESTRICT pY,
463 const BYTE* WINPR_RESTRICT pU,
464 const BYTE* WINPR_RESTRICT pV, size_t nWidth)
465{
466 WINPR_ASSERT(nWidth % 2 == 0);
467 for (size_t x = 0; x < nWidth; x += 2)
468 {
469 for (size_t j = 0; j < 2; j++)
470 {
471 const BYTE Y = pY[x + j];
472 const BYTE U = pU[x + j];
473 const BYTE V = pV[x + j];
474 pRGB = writeYUVPixel(pRGB, DstFormat, Y, U, V, writePixelBGRX);
475 }
476 }
477}
478
479static inline pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc[3],
480 const UINT32 srcStep[3],
481 BYTE* WINPR_RESTRICT pDst,
482 UINT32 dstStep, UINT32 DstFormat,
483 const prim_size_t* WINPR_RESTRICT roi)
484{
485 WINPR_ASSERT(pSrc);
486 WINPR_ASSERT(pDst);
487 WINPR_ASSERT(roi);
488
489 const UINT32 nWidth = roi->width;
490 const UINT32 nHeight = roi->height;
491
492 size_t y = 0;
493 for (; y < nHeight - nHeight % 2; y += 2)
494 {
495 const BYTE* pY[2] = { pSrc[0] + y * srcStep[0], pSrc[0] + (y + 1) * srcStep[0] };
496 const BYTE* pU[2] = { pSrc[1] + y * srcStep[1], pSrc[1] + (y + 1) * srcStep[1] };
497 const BYTE* pV[2] = { pSrc[2] + y * srcStep[2], pSrc[2] + (y + 1) * srcStep[2] };
498 BYTE* pRGB[] = { pDst + y * dstStep, pDst + (y + 1) * dstStep };
499
500 general_YUV444ToBGRX_DOUBLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
501 }
502
503 for (; y < nHeight; y++)
504 {
505 const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
506 const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
507 const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
508 BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
509
510 general_YUV444ToBGRX_SINGLE_ROW(pRGB, DstFormat, pY, pU, pV, nWidth);
511 }
512 return PRIMITIVES_SUCCESS;
513}
514
515static pstatus_t general_YUV444ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
516 const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
517 UINT32 dstStep, UINT32 DstFormat,
518 const prim_size_t* WINPR_RESTRICT roi)
519{
520 switch (DstFormat)
521 {
522 case PIXEL_FORMAT_BGRA32:
523 case PIXEL_FORMAT_BGRX32:
524 return general_YUV444ToRGB_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, DstFormat, roi);
525
526 default:
527 return general_YUV444ToRGB_8u_P3AC4R_general(pSrc, srcStep, pDst, dstStep, DstFormat,
528 roi);
529 }
530}
531
539static pstatus_t general_I444ToRGB_8u(const BYTE* WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],
540 BYTE* WINPR_RESTRICT pDst, UINT32 dstStep, UINT32 DstFormat,
541 const prim_size_t* WINPR_RESTRICT roi)
542{
543 WINPR_ASSERT(pSrc);
544 WINPR_ASSERT(srcStep);
545 WINPR_ASSERT(pDst);
546 WINPR_ASSERT(roi);
547
548 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
549
550 for (size_t y = 0; y < roi->height; y++)
551 {
552 const BYTE* WINPR_RESTRICT pY = pSrc[0] + y * srcStep[0];
553 const BYTE* WINPR_RESTRICT pU = pSrc[1] + y * srcStep[1];
554 const BYTE* WINPR_RESTRICT pV = pSrc[2] + y * srcStep[2];
555 BYTE* WINPR_RESTRICT pRGB = pDst + y * dstStep;
556
557 for (size_t x = 0; x < roi->width; x++)
558 pRGB = writeYUVPixel(pRGB, DstFormat, pY[x], pU[x], pV[x], writePixel);
559 }
560
561 return PRIMITIVES_SUCCESS;
562}
563
569static void general_YUV420ToRGB_8u_P3AC4R_double_line(BYTE* WINPR_RESTRICT pEven,
570 BYTE* WINPR_RESTRICT pOdd, UINT32 DstFormat,
571 const BYTE* WINPR_RESTRICT pYeven,
572 const BYTE* WINPR_RESTRICT pYodd,
573 const BYTE* WINPR_RESTRICT pU,
574 const BYTE* WINPR_RESTRICT pV, UINT32 width,
575 fkt_writePixel writePixel, UINT32 formatSize)
576{
577
578 UINT32 x = 0;
579 for (; x < width / 2; x++)
580 {
581 const BYTE U = pU[x];
582 const BYTE V = pV[x];
583 const BYTE eY0 = pYeven[2ULL * x + 0];
584 const BYTE eY1 = pYeven[2ULL * x + 1];
585 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
586 writeYUVPixel(&pEven[(2ULL * x + 1) * formatSize], DstFormat, eY1, U, V, writePixel);
587
588 const BYTE oY0 = pYodd[2ULL * x + 0];
589 const BYTE oY1 = pYodd[2ULL * x + 1];
590 writeYUVPixel(&pOdd[2ULL * x * formatSize], DstFormat, oY0, U, V, writePixel);
591 writeYUVPixel(&pOdd[(2ULL * x + 1) * formatSize], DstFormat, oY1, U, V, writePixel);
592 }
593
594 for (; x < (width + 1) / 2; x++)
595 {
596 const BYTE U = pU[x];
597 const BYTE V = pV[x];
598 const BYTE eY0 = pYeven[2ULL * x + 0];
599 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
600
601 const BYTE oY0 = pYodd[2ULL * x + 0];
602 writeYUVPixel(&pOdd[2ULL * x * formatSize], DstFormat, oY0, U, V, writePixel);
603 }
604}
605
606static void general_YUV420ToRGB_8u_P3AC4R_single_line(BYTE* WINPR_RESTRICT pEven, UINT32 DstFormat,
607 const BYTE* WINPR_RESTRICT pYeven,
608 const BYTE* WINPR_RESTRICT pU,
609 const BYTE* WINPR_RESTRICT pV, UINT32 width,
610 fkt_writePixel writePixel, UINT32 formatSize)
611{
612
613 UINT32 x = 0;
614 for (; x < width / 2; x++)
615 {
616 const BYTE U = pU[x];
617 const BYTE V = pV[x];
618 const BYTE eY0 = pYeven[2ULL * x + 0];
619 const BYTE eY1 = pYeven[2ULL * x + 1];
620 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
621 writeYUVPixel(&pEven[(2ULL * x + 1) * formatSize], DstFormat, eY1, U, V, writePixel);
622 }
623
624 for (; x < (width + 1) / 2; x++)
625 {
626 const BYTE U = pU[x];
627 const BYTE V = pV[x];
628 const BYTE eY0 = pYeven[2ULL * x + 0];
629 writeYUVPixel(&pEven[2ULL * x * formatSize], DstFormat, eY0, U, V, writePixel);
630 }
631}
632
633static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc[3],
634 const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,
635 UINT32 dstStep, UINT32 DstFormat,
636 const prim_size_t* WINPR_RESTRICT roi)
637{
638 WINPR_ASSERT(roi);
639 const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);
640 fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);
641 const UINT32 nWidth = roi->width;
642 const UINT32 nHeight = roi->height;
643
644 UINT32 y = 0;
645 for (; y < nHeight / 2; y++)
646 {
647 const BYTE* pYe = &pSrc[0][(2ULL * y + 0) * srcStep[0]];
648 const BYTE* pYo = &pSrc[0][(2ULL * y + 1) * srcStep[0]];
649 const BYTE* pU = &pSrc[1][1ULL * srcStep[1] * y];
650 const BYTE* pV = &pSrc[2][1ULL * srcStep[2] * y];
651 BYTE* pRGBeven = &pDst[2ULL * y * dstStep];
652 BYTE* pRGBodd = &pDst[(2ULL * y + 1) * dstStep];
653 general_YUV420ToRGB_8u_P3AC4R_double_line(pRGBeven, pRGBodd, DstFormat, pYe, pYo, pU, pV,
654 nWidth, writePixel, formatSize);
655 }
656
657 // Last row (if odd)
658 for (; y < (nHeight + 1) / 2; y++)
659 {
660 const BYTE* pY = &pSrc[0][2ULL * srcStep[0] * y];
661 const BYTE* pU = &pSrc[1][1ULL * srcStep[1] * y];
662 const BYTE* pV = &pSrc[2][1ULL * srcStep[2] * y];
663 BYTE* pEven = &pDst[2ULL * y * dstStep];
664
665 general_YUV420ToRGB_8u_P3AC4R_single_line(pEven, DstFormat, pY, pU, pV, nWidth, writePixel,
666 formatSize);
667 }
668
669 return PRIMITIVES_SUCCESS;
670}
671
672static inline void BGRX_fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2],
673 BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
674 BYTE* WINPR_RESTRICT pV[2])
675{
676 WINPR_ASSERT(pRGB);
677 WINPR_ASSERT(pY);
678 WINPR_ASSERT(pU);
679 WINPR_ASSERT(pV);
680
681 const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
682 const UINT32 bpp = 4;
683
684 for (size_t i = 0; i < 2; i++)
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[i][(offset + j) * bpp], SrcFormat);
692 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
693 pY[i][offset + j] = RGB2Y(R, G, B);
694 pU[i][offset + j] = RGB2U(R, G, B);
695 pV[i][offset + j] = RGB2V(R, G, B);
696 }
697 }
698
699 /* Apply chroma filter */
700 const INT32 avgU = (pU[0][offset] + pU[0][offset + 1] + pU[1][offset] + pU[1][offset + 1]) / 4;
701 pU[0][offset] = CONDITIONAL_CLIP(avgU, pU[0][offset]);
702 const INT32 avgV = (pV[0][offset] + pV[0][offset + 1] + pV[1][offset] + pV[1][offset + 1]) / 4;
703 pV[0][offset] = CONDITIONAL_CLIP(avgV, pV[0][offset]);
704}
705
706static inline void BGRX_fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB,
707 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
708 BYTE* WINPR_RESTRICT pV)
709{
710 WINPR_ASSERT(pRGB);
711 WINPR_ASSERT(pY);
712 WINPR_ASSERT(pU);
713 WINPR_ASSERT(pV);
714
715 const UINT32 SrcFormat = PIXEL_FORMAT_BGRX32;
716 const UINT32 bpp = 4;
717
718 for (size_t j = 0; j < 2; j++)
719 {
720 BYTE B = 0;
721 BYTE G = 0;
722 BYTE R = 0;
723 const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
724 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
725 pY[offset + j] = RGB2Y(R, G, B);
726 pU[offset + j] = RGB2U(R, G, B);
727 pV[offset + j] = RGB2V(R, G, B);
728 }
729}
730
731static inline void general_BGRXToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
732 BYTE* WINPR_RESTRICT pY[2],
733 BYTE* WINPR_RESTRICT pU[2],
734 BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
735{
736 for (size_t x = 0; x < nWidth; x += 2)
737 {
738 BGRX_fillYUV(x, pRGB, pY, pU, pV);
739 }
740}
741
742static inline void general_BGRXToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB,
743 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
744 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
745{
746 for (size_t x = 0; x < nWidth; x += 2)
747 {
748 BGRX_fillYUV_single(x, pRGB, pY, pU, pV);
749 }
750}
751
752static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_BGRX(const BYTE* WINPR_RESTRICT pSrc,
753 const UINT32 srcStep,
754 BYTE* WINPR_RESTRICT pDst[3],
755 const UINT32 dstStep[3],
756 const prim_size_t* WINPR_RESTRICT roi)
757{
758 const UINT32 nWidth = roi->width;
759 const UINT32 nHeight = roi->height;
760
761 size_t y = 0;
762 for (; y < nHeight - nHeight % 2; y += 2)
763 {
764 const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
765 BYTE* pY[] = { pDst[0] + y * dstStep[0], pDst[0] + (y + 1) * dstStep[0] };
766 BYTE* pU[] = { pDst[1] + y * dstStep[1], pDst[1] + (y + 1) * dstStep[1] };
767 BYTE* pV[] = { pDst[2] + y * dstStep[2], pDst[2] + (y + 1) * dstStep[2] };
768
769 general_BGRXToYUV444_DOUBLE_ROW(pRGB, pY, pU, pV, nWidth);
770 }
771
772 for (; y < nHeight; y++)
773 {
774 const BYTE* pRGB = pSrc + y * srcStep;
775 BYTE* pY = pDst[0] + y * dstStep[0];
776 BYTE* pU = pDst[1] + y * dstStep[1];
777 BYTE* pV = pDst[2] + y * dstStep[2];
778
779 general_BGRXToYUV444_SINGLE_ROW(pRGB, pY, pU, pV, nWidth);
780 }
781
782 return PRIMITIVES_SUCCESS;
783}
784
785static inline void fillYUV(size_t offset, const BYTE* WINPR_RESTRICT pRGB[2], UINT32 SrcFormat,
786 BYTE* WINPR_RESTRICT pY[2], BYTE* WINPR_RESTRICT pU[2],
787 BYTE* WINPR_RESTRICT pV[2])
788{
789 WINPR_ASSERT(pRGB);
790 WINPR_ASSERT(pY);
791 WINPR_ASSERT(pU);
792 WINPR_ASSERT(pV);
793 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
794
795 INT32 avgU = 0;
796 INT32 avgV = 0;
797 for (size_t i = 0; i < 2; i++)
798 {
799 for (size_t j = 0; j < 2; j++)
800 {
801 BYTE B = 0;
802 BYTE G = 0;
803 BYTE R = 0;
804 const UINT32 color = FreeRDPReadColor(&pRGB[i][(offset + j) * bpp], SrcFormat);
805 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
806 const BYTE y = RGB2Y(R, G, B);
807 const BYTE u = RGB2U(R, G, B);
808 const BYTE v = RGB2V(R, G, B);
809 avgU += u;
810 avgV += v;
811 pY[i][offset + j] = y;
812 pU[i][offset + j] = u;
813 pV[i][offset + j] = v;
814 }
815 }
816
817 /* Apply chroma filter */
818 avgU /= 4;
819 pU[0][offset] = CLIP(avgU);
820
821 avgV /= 4;
822 pV[0][offset] = CLIP(avgV);
823}
824
825static inline void fillYUV_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
826 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
827 BYTE* WINPR_RESTRICT pV)
828{
829 WINPR_ASSERT(pRGB);
830 WINPR_ASSERT(pY);
831 WINPR_ASSERT(pU);
832 WINPR_ASSERT(pV);
833 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
834
835 for (size_t j = 0; j < 2; j++)
836 {
837 BYTE B = 0;
838 BYTE G = 0;
839 BYTE R = 0;
840 const UINT32 color = FreeRDPReadColor(&pRGB[(offset + j) * bpp], SrcFormat);
841 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
842 const BYTE y = RGB2Y(R, G, B);
843 const BYTE u = RGB2U(R, G, B);
844 const BYTE v = RGB2V(R, G, B);
845 pY[offset + j] = y;
846 pU[offset + j] = u;
847 pV[offset + j] = v;
848 }
849}
850
851static inline void general_RGBToYUV444_DOUBLE_ROW(const BYTE* WINPR_RESTRICT pRGB[2],
852 UINT32 SrcFormat, BYTE* WINPR_RESTRICT pY[2],
853 BYTE* WINPR_RESTRICT pU[2],
854 BYTE* WINPR_RESTRICT pV[2], UINT32 nWidth)
855{
856 for (size_t x = 0; x < nWidth; x += 2)
857 {
858 fillYUV(x, pRGB, SrcFormat, pY, pU, pV);
859 }
860}
861
862static inline void general_RGBToYUV444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
863 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
864 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
865{
866 for (size_t x = 0; x < nWidth; x += 2)
867 {
868 fillYUV_single(x, pRGB, SrcFormat, pY, pU, pV);
869 }
870}
871
872static inline pstatus_t general_RGBToYUV444_8u_P3AC4R_RGB(const BYTE* WINPR_RESTRICT pSrc,
873 UINT32 SrcFormat, const UINT32 srcStep,
874 BYTE* WINPR_RESTRICT pDst[3],
875 const UINT32 dstStep[3],
876 const prim_size_t* WINPR_RESTRICT roi)
877{
878 const UINT32 nWidth = roi->width;
879 const UINT32 nHeight = roi->height;
880
881 size_t y = 0;
882 for (; y < nHeight - nHeight % 2; y += 2)
883 {
884 const BYTE* pRGB[] = { pSrc + y * srcStep, pSrc + (y + 1) * srcStep };
885 BYTE* pY[] = { &pDst[0][y * dstStep[0]], &pDst[0][(y + 1) * dstStep[0]] };
886 BYTE* pU[] = { &pDst[1][y * dstStep[1]], &pDst[1][(y + 1) * dstStep[1]] };
887 BYTE* pV[] = { &pDst[2][y * dstStep[2]], &pDst[2][(y + 1) * dstStep[2]] };
888
889 general_RGBToYUV444_DOUBLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
890 }
891 for (; y < nHeight; y++)
892 {
893 const BYTE* pRGB = pSrc + y * srcStep;
894 BYTE* pY = &pDst[0][y * dstStep[0]];
895 BYTE* pU = &pDst[1][y * dstStep[1]];
896 BYTE* pV = &pDst[2][y * dstStep[2]];
897
898 general_RGBToYUV444_SINGLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
899 }
900
901 return PRIMITIVES_SUCCESS;
902}
903
904static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
905 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
906 const UINT32 dstStep[3],
907 const prim_size_t* WINPR_RESTRICT roi)
908{
909 switch (SrcFormat)
910 {
911 case PIXEL_FORMAT_BGRA32:
912 case PIXEL_FORMAT_BGRX32:
913 return general_RGBToYUV444_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, roi);
914 default:
915 return general_RGBToYUV444_8u_P3AC4R_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
916 }
917}
918
919static inline void fillI444_single(size_t offset, const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
920 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
921 BYTE* WINPR_RESTRICT pV)
922{
923 WINPR_ASSERT(pRGB);
924 WINPR_ASSERT(pY);
925 WINPR_ASSERT(pU);
926 WINPR_ASSERT(pV);
927
928 const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);
929
930 BYTE B = 0;
931 BYTE G = 0;
932 BYTE R = 0;
933 const UINT32 color = FreeRDPReadColor(&pRGB[offset * bpp], SrcFormat);
934 FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, nullptr, nullptr);
935 const BYTE y = RGB2Y(R, G, B);
936 const BYTE u = RGB2U(R, G, B);
937 const BYTE v = RGB2V(R, G, B);
938 pY[offset] = y;
939 pU[offset] = u;
940 pV[offset] = v;
941}
942
943static inline void general_RGBToI444_SINGLE_ROW(const BYTE* WINPR_RESTRICT pRGB, UINT32 SrcFormat,
944 BYTE* WINPR_RESTRICT pY, BYTE* WINPR_RESTRICT pU,
945 BYTE* WINPR_RESTRICT pV, UINT32 nWidth)
946{
947 for (size_t x = 0; x < nWidth; x++)
948 {
949 fillI444_single(x, pRGB, SrcFormat, pY, pU, pV);
950 }
951}
952
953static inline pstatus_t general_RGBToI444_8u_RGB(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
954 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
955 const UINT32 dstStep[3],
956 const prim_size_t* WINPR_RESTRICT roi)
957{
958 const UINT32 nWidth = roi->width;
959 const UINT32 nHeight = roi->height;
960
961 for (size_t y = 0; y < nHeight; y++)
962 {
963 const BYTE* pRGB = pSrc + y * srcStep;
964 BYTE* pY = &pDst[0][y * dstStep[0]];
965 BYTE* pU = &pDst[1][y * dstStep[1]];
966 BYTE* pV = &pDst[2][y * dstStep[2]];
967
968 general_RGBToI444_SINGLE_ROW(pRGB, SrcFormat, pY, pU, pV, nWidth);
969 }
970
971 return PRIMITIVES_SUCCESS;
972}
973
974/* 32 bit formats keep each colour at a fixed byte offset, so read the bytes
975 * directly instead of decoding every pixel with FreeRDPReadColor and
976 * FreeRDPSplitColor; the compiler can vectorize this loop */
977static inline pstatus_t
978general_RGBToI444_8u_32bpp(const BYTE* WINPR_RESTRICT pSrc, const UINT32 srcStep,
979 BYTE* WINPR_RESTRICT pDst[3], const UINT32 dstStep[3],
980 const prim_size_t* WINPR_RESTRICT roi, const size_t rOff,
981 const size_t gOff, const size_t bOff)
982{
983 const UINT32 nWidth = roi->width;
984 const UINT32 nHeight = roi->height;
985
986 for (size_t y = 0; y < nHeight; y++)
987 {
988 const BYTE* WINPR_RESTRICT pRGB = pSrc + y * srcStep;
989 BYTE* WINPR_RESTRICT pY = &pDst[0][y * dstStep[0]];
990 BYTE* WINPR_RESTRICT pU = &pDst[1][y * dstStep[1]];
991 BYTE* WINPR_RESTRICT pV = &pDst[2][y * dstStep[2]];
992
993 for (size_t x = 0; x < nWidth; x++)
994 {
995 const BYTE* px = &pRGB[4ULL * x];
996 const BYTE R = px[rOff];
997 const BYTE G = px[gOff];
998 const BYTE B = px[bOff];
999 pY[x] = RGB2Y(R, G, B);
1000 pU[x] = RGB2U(R, G, B);
1001 pV[x] = RGB2V(R, G, B);
1002 }
1003 }
1004
1005 return PRIMITIVES_SUCCESS;
1006}
1007
1008static pstatus_t general_RGBToI444_8u(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
1009 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1010 const UINT32 dstStep[3],
1011 const prim_size_t* WINPR_RESTRICT roi)
1012{
1013 /* FreeRDPReadColor reads 32 bit pixels most significant byte first: the
1014 * first channel of the format name is the first byte in memory */
1015 switch (SrcFormat)
1016 {
1017 case PIXEL_FORMAT_BGRA32:
1018 case PIXEL_FORMAT_BGRX32:
1019 return general_RGBToI444_8u_32bpp(pSrc, srcStep, pDst, dstStep, roi, 2, 1, 0);
1020 case PIXEL_FORMAT_RGBA32:
1021 case PIXEL_FORMAT_RGBX32:
1022 return general_RGBToI444_8u_32bpp(pSrc, srcStep, pDst, dstStep, roi, 0, 1, 2);
1023 case PIXEL_FORMAT_ARGB32:
1024 case PIXEL_FORMAT_XRGB32:
1025 return general_RGBToI444_8u_32bpp(pSrc, srcStep, pDst, dstStep, roi, 1, 2, 3);
1026 case PIXEL_FORMAT_ABGR32:
1027 case PIXEL_FORMAT_XBGR32:
1028 return general_RGBToI444_8u_32bpp(pSrc, srcStep, pDst, dstStep, roi, 3, 2, 1);
1029 default:
1030 return general_RGBToI444_8u_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
1031 }
1032}
1033
1034static inline pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1035 BYTE* WINPR_RESTRICT pDst[3],
1036 const UINT32 dstStep[3],
1037 const prim_size_t* WINPR_RESTRICT roi)
1038{
1039 size_t x1 = 0;
1040 size_t x2 = 4;
1041 size_t x3 = srcStep;
1042 size_t x4 = srcStep + 4;
1043 size_t y1 = 0;
1044 size_t y2 = 1;
1045 size_t y3 = dstStep[0];
1046 size_t y4 = dstStep[0] + 1;
1047 UINT32 max_x = roi->width - 1;
1048
1049 size_t y = 0;
1050 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1051 {
1052 const BYTE* src = pSrc + y * srcStep;
1053 BYTE* ydst = pDst[0] + y * dstStep[0];
1054 BYTE* udst = pDst[1] + i * dstStep[1];
1055 BYTE* vdst = pDst[2] + i * dstStep[2];
1056
1057 for (size_t x = 0; x < roi->width; x += 2)
1058 {
1059 BYTE R = 0;
1060 BYTE G = 0;
1061 BYTE B = 0;
1062 INT32 Ra = 0;
1063 INT32 Ga = 0;
1064 INT32 Ba = 0;
1065 /* row 1, pixel 1 */
1066 Ba = B = *(src + x1 + 0);
1067 Ga = G = *(src + x1 + 1);
1068 Ra = R = *(src + x1 + 2);
1069 ydst[y1] = RGB2Y(R, G, B);
1070
1071 if (x < max_x)
1072 {
1073 /* row 1, pixel 2 */
1074 Ba += B = *(src + x2 + 0);
1075 Ga += G = *(src + x2 + 1);
1076 Ra += R = *(src + x2 + 2);
1077 ydst[y2] = RGB2Y(R, G, B);
1078 }
1079
1080 /* row 2, pixel 1 */
1081 Ba += B = *(src + x3 + 0);
1082 Ga += G = *(src + x3 + 1);
1083 Ra += R = *(src + x3 + 2);
1084 ydst[y3] = RGB2Y(R, G, B);
1085
1086 if (x < max_x)
1087 {
1088 /* row 2, pixel 2 */
1089 Ba += B = *(src + x4 + 0);
1090 Ga += G = *(src + x4 + 1);
1091 Ra += R = *(src + x4 + 2);
1092 ydst[y4] = RGB2Y(R, G, B);
1093 }
1094
1095 Ba >>= 2;
1096 Ga >>= 2;
1097 Ra >>= 2;
1098 *udst++ = RGB2U(Ra, Ga, Ba);
1099 *vdst++ = RGB2V(Ra, Ga, Ba);
1100 ydst += 2;
1101 src += 8;
1102 }
1103 }
1104
1105 for (; y < roi->height; y++)
1106 {
1107 const BYTE* src = pSrc + y * srcStep;
1108 BYTE* ydst = pDst[0] + y * dstStep[0];
1109 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1110 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1111
1112 for (size_t x = 0; x < roi->width; x += 2)
1113 {
1114 BYTE R = 0;
1115 BYTE G = 0;
1116 BYTE B = 0;
1117 INT32 Ra = 0;
1118 INT32 Ga = 0;
1119 INT32 Ba = 0;
1120 /* row 1, pixel 1 */
1121 Ba = B = *(src + x1 + 0);
1122 Ga = G = *(src + x1 + 1);
1123 Ra = R = *(src + x1 + 2);
1124 ydst[y1] = RGB2Y(R, G, B);
1125
1126 if (x < max_x)
1127 {
1128 /* row 1, pixel 2 */
1129 Ba += B = *(src + x2 + 0);
1130 Ga += G = *(src + x2 + 1);
1131 Ra += R = *(src + x2 + 2);
1132 ydst[y2] = RGB2Y(R, G, B);
1133 }
1134
1135 Ba >>= 2;
1136 Ga >>= 2;
1137 Ra >>= 2;
1138 *udst++ = RGB2U(Ra, Ga, Ba);
1139 *vdst++ = RGB2V(Ra, Ga, Ba);
1140 ydst += 2;
1141 src += 8;
1142 }
1143 }
1144
1145 return PRIMITIVES_SUCCESS;
1146}
1147
1148static inline pstatus_t general_RGBToYUV420_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1149 BYTE* WINPR_RESTRICT pDst[3],
1150 const UINT32 dstStep[3],
1151 const prim_size_t* WINPR_RESTRICT roi)
1152{
1153 size_t x1 = 0;
1154 size_t x2 = 4;
1155 size_t x3 = srcStep;
1156 size_t x4 = srcStep + 4;
1157 size_t y1 = 0;
1158 size_t y2 = 1;
1159 size_t y3 = dstStep[0];
1160 size_t y4 = dstStep[0] + 1;
1161 UINT32 max_x = roi->width - 1;
1162
1163 size_t y = 0;
1164 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1165 {
1166 const BYTE* src = pSrc + y * srcStep;
1167 BYTE* ydst = pDst[0] + y * dstStep[0];
1168 BYTE* udst = pDst[1] + i * dstStep[1];
1169 BYTE* vdst = pDst[2] + i * dstStep[2];
1170
1171 for (UINT32 x = 0; x < roi->width; x += 2)
1172 {
1173 BYTE R = *(src + x1 + 0);
1174 BYTE G = *(src + x1 + 1);
1175 BYTE B = *(src + x1 + 2);
1176 /* row 1, pixel 1 */
1177 INT32 Ra = R;
1178 INT32 Ga = G;
1179 INT32 Ba = B;
1180 ydst[y1] = RGB2Y(R, G, B);
1181
1182 if (x < max_x)
1183 {
1184 /* row 1, pixel 2 */
1185 R = *(src + x2 + 0);
1186 G = *(src + x2 + 1);
1187 B = *(src + x2 + 2);
1188 Ra += R;
1189 Ga += G;
1190 Ba += B;
1191 ydst[y2] = RGB2Y(R, G, B);
1192 }
1193
1194 /* row 2, pixel 1 */
1195 R = *(src + x3 + 0);
1196 G = *(src + x3 + 1);
1197 B = *(src + x3 + 2);
1198
1199 Ra += R;
1200 Ga += G;
1201 Ba += B;
1202 ydst[y3] = RGB2Y(R, G, B);
1203
1204 if (x < max_x)
1205 {
1206 /* row 2, pixel 2 */
1207 R = *(src + x4 + 0);
1208 G = *(src + x4 + 1);
1209 B = *(src + x4 + 2);
1210
1211 Ra += R;
1212 Ga += G;
1213 Ba += B;
1214 ydst[y4] = RGB2Y(R, G, B);
1215 }
1216
1217 Ba >>= 2;
1218 Ga >>= 2;
1219 Ra >>= 2;
1220 *udst++ = RGB2U(Ra, Ga, Ba);
1221 *vdst++ = RGB2V(Ra, Ga, Ba);
1222 ydst += 2;
1223 src += 8;
1224 }
1225 }
1226
1227 for (; y < roi->height; y++)
1228 {
1229 const BYTE* src = pSrc + y * srcStep;
1230 BYTE* ydst = pDst[0] + y * dstStep[0];
1231 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1232 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1233
1234 for (UINT32 x = 0; x < roi->width; x += 2)
1235 {
1236 BYTE R = *(src + x1 + 0);
1237 BYTE G = *(src + x1 + 1);
1238 BYTE B = *(src + x1 + 2);
1239 /* row 1, pixel 1 */
1240 INT32 Ra = R;
1241 INT32 Ga = G;
1242 INT32 Ba = B;
1243 ydst[y1] = RGB2Y(R, G, B);
1244
1245 if (x < max_x)
1246 {
1247 /* row 1, pixel 2 */
1248 R = *(src + x2 + 0);
1249 G = *(src + x2 + 1);
1250 B = *(src + x2 + 2);
1251 Ra += R;
1252 Ga += G;
1253 Ba += B;
1254 ydst[y2] = RGB2Y(R, G, B);
1255 }
1256
1257 Ba >>= 2;
1258 Ga >>= 2;
1259 Ra >>= 2;
1260 *udst++ = RGB2U(Ra, Ga, Ba);
1261 *vdst++ = RGB2V(Ra, Ga, Ba);
1262 ydst += 2;
1263 src += 8;
1264 }
1265 }
1266
1267 return PRIMITIVES_SUCCESS;
1268}
1269
1270static inline pstatus_t general_RGBToYUV420_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1271 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1272 const UINT32 dstStep[3],
1273 const prim_size_t* WINPR_RESTRICT roi)
1274{
1275 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1276 size_t x1 = 0;
1277 size_t x2 = bpp;
1278 size_t x3 = srcStep;
1279 size_t x4 = srcStep + bpp;
1280 size_t y1 = 0;
1281 size_t y2 = 1;
1282 size_t y3 = dstStep[0];
1283 size_t y4 = dstStep[0] + 1;
1284 UINT32 max_x = roi->width - 1;
1285
1286 size_t y = 0;
1287 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1288 {
1289 const BYTE* src = pSrc + y * srcStep;
1290 BYTE* ydst = pDst[0] + y * dstStep[0];
1291 BYTE* udst = pDst[1] + i * dstStep[1];
1292 BYTE* vdst = pDst[2] + i * dstStep[2];
1293
1294 for (size_t x = 0; x < roi->width; x += 2)
1295 {
1296 BYTE R = 0;
1297 BYTE G = 0;
1298 BYTE B = 0;
1299 INT32 Ra = 0;
1300 INT32 Ga = 0;
1301 INT32 Ba = 0;
1302 UINT32 color = 0;
1303 /* row 1, pixel 1 */
1304 color = FreeRDPReadColor(src + x1, srcFormat);
1305 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1306 Ra = R;
1307 Ga = G;
1308 Ba = B;
1309 ydst[y1] = RGB2Y(R, G, B);
1310
1311 if (x < max_x)
1312 {
1313 /* row 1, pixel 2 */
1314 color = FreeRDPReadColor(src + x2, srcFormat);
1315 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1316 Ra += R;
1317 Ga += G;
1318 Ba += B;
1319 ydst[y2] = RGB2Y(R, G, B);
1320 }
1321
1322 /* row 2, pixel 1 */
1323 color = FreeRDPReadColor(src + x3, srcFormat);
1324 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1325 Ra += R;
1326 Ga += G;
1327 Ba += B;
1328 ydst[y3] = RGB2Y(R, G, B);
1329
1330 if (x < max_x)
1331 {
1332 /* row 2, pixel 2 */
1333 color = FreeRDPReadColor(src + x4, srcFormat);
1334 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1335 Ra += R;
1336 Ga += G;
1337 Ba += B;
1338 ydst[y4] = RGB2Y(R, G, B);
1339 }
1340
1341 Ra >>= 2;
1342 Ga >>= 2;
1343 Ba >>= 2;
1344 *udst++ = RGB2U(Ra, Ga, Ba);
1345 *vdst++ = RGB2V(Ra, Ga, Ba);
1346 ydst += 2;
1347 src += 2ULL * bpp;
1348 }
1349 }
1350
1351 for (; y < roi->height; y++)
1352 {
1353 const BYTE* src = pSrc + y * srcStep;
1354 BYTE* ydst = pDst[0] + y * dstStep[0];
1355 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1356 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1357
1358 for (size_t x = 0; x < roi->width; x += 2)
1359 {
1360 BYTE R = 0;
1361 BYTE G = 0;
1362 BYTE B = 0;
1363 /* row 1, pixel 1 */
1364 UINT32 color = FreeRDPReadColor(src + x1, srcFormat);
1365 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1366 INT32 Ra = R;
1367 INT32 Ga = G;
1368 INT32 Ba = B;
1369 ydst[y1] = RGB2Y(R, G, B);
1370
1371 if (x < max_x)
1372 {
1373 /* row 1, pixel 2 */
1374 color = FreeRDPReadColor(src + x2, srcFormat);
1375 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1376 Ra += R;
1377 Ga += G;
1378 Ba += B;
1379 ydst[y2] = RGB2Y(R, G, B);
1380 }
1381
1382 Ra >>= 2;
1383 Ga >>= 2;
1384 Ba >>= 2;
1385 *udst++ = RGB2U(Ra, Ga, Ba);
1386 *vdst++ = RGB2V(Ra, Ga, Ba);
1387 ydst += 2;
1388 src += 2ULL * bpp;
1389 }
1390 }
1391
1392 return PRIMITIVES_SUCCESS;
1393}
1394
1395static pstatus_t general_RGBToYUV420_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1396 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1397 const UINT32 dstStep[3],
1398 const prim_size_t* WINPR_RESTRICT roi)
1399{
1400 switch (srcFormat)
1401 {
1402 case PIXEL_FORMAT_BGRA32:
1403 case PIXEL_FORMAT_BGRX32:
1404 return general_RGBToYUV420_BGRX(pSrc, srcStep, pDst, dstStep, roi);
1405
1406 case PIXEL_FORMAT_RGBA32:
1407 case PIXEL_FORMAT_RGBX32:
1408 return general_RGBToYUV420_RGBX(pSrc, srcStep, pDst, dstStep, roi);
1409
1410 default:
1411 return general_RGBToYUV420_ANY(pSrc, srcFormat, srcStep, pDst, dstStep, roi);
1412 }
1413}
1414
1415static inline void int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
1416 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
1417 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1418 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1419 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1420{
1421 for (size_t x = offset; x < width; x += 2)
1422 {
1423 const BYTE* srcEven = &pSrcEven[4ULL * x];
1424 const BYTE* srcOdd = &pSrcOdd[4ULL * x];
1425 const BOOL lastX = (x + 1) >= width;
1426 BYTE Y1e = 0;
1427 BYTE Y2e = 0;
1428 BYTE U1e = 0;
1429 BYTE V1e = 0;
1430 BYTE U2e = 0;
1431 BYTE V2e = 0;
1432 BYTE Y1o = 0;
1433 BYTE Y2o = 0;
1434 BYTE U1o = 0;
1435 BYTE V1o = 0;
1436 BYTE U2o = 0;
1437 BYTE V2o = 0;
1438 /* Read 4 pixels, 2 from even, 2 from odd lines */
1439 {
1440 const BYTE b = *srcEven++;
1441 const BYTE g = *srcEven++;
1442 const BYTE r = *srcEven++;
1443 srcEven++;
1444 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1445 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1446 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1447 }
1448
1449 if (!lastX)
1450 {
1451 const BYTE b = *srcEven++;
1452 const BYTE g = *srcEven++;
1453 const BYTE r = *srcEven++;
1454 srcEven++;
1455 Y2e = RGB2Y(r, g, b);
1456 U2e = RGB2U(r, g, b);
1457 V2e = RGB2V(r, g, b);
1458 }
1459
1460 if (b1Odd)
1461 {
1462 const BYTE b = *srcOdd++;
1463 const BYTE g = *srcOdd++;
1464 const BYTE r = *srcOdd++;
1465 srcOdd++;
1466 Y1o = Y2o = RGB2Y(r, g, b);
1467 U1o = U2o = RGB2U(r, g, b);
1468 V1o = V2o = RGB2V(r, g, b);
1469 }
1470
1471 if (b1Odd && !lastX)
1472 {
1473 const BYTE b = *srcOdd++;
1474 const BYTE g = *srcOdd++;
1475 const BYTE r = *srcOdd++;
1476 srcOdd++;
1477 Y2o = RGB2Y(r, g, b);
1478 U2o = RGB2U(r, g, b);
1479 V2o = RGB2V(r, g, b);
1480 }
1481
1482 /* We have 4 Y pixels, so store them. */
1483 *b1Even++ = Y1e;
1484 *b1Even++ = Y2e;
1485
1486 if (b1Odd)
1487 {
1488 *b1Odd++ = Y1o;
1489 *b1Odd++ = Y2o;
1490 }
1491
1492 /* 2x 2y pixel in luma UV plane use averaging
1493 */
1494 {
1495 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1496 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1497 *b2++ = Uavg;
1498 *b3++ = Vavg;
1499 }
1500
1501 /* UV from 2x, 2y+1 */
1502 if (b1Odd)
1503 {
1504 *b4++ = U1o;
1505 *b5++ = V1o;
1506
1507 if (!lastX)
1508 {
1509 *b4++ = U2o;
1510 *b5++ = V2o;
1511 }
1512 }
1513
1514 /* UV from 2x+1, 2y */
1515 if (!lastX)
1516 {
1517 *b6++ = U2e;
1518 *b7++ = V2e;
1519 }
1520 }
1521}
1522
1523void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(size_t offset, const BYTE* WINPR_RESTRICT pSrcEven,
1524 const BYTE* WINPR_RESTRICT pSrcOdd,
1525 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd,
1526 BYTE* WINPR_RESTRICT b2, BYTE* WINPR_RESTRICT b3,
1527 BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1528 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7,
1529 UINT32 width)
1530{
1531 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(offset, pSrcEven, pSrcOdd, b1Even, b1Odd, b2, b3, b4,
1532 b5, b6, b7, width);
1533}
1534
1535static inline pstatus_t general_RGBToAVC444YUV_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1536 BYTE* WINPR_RESTRICT pDst1[3],
1537 const UINT32 dst1Step[3],
1538 BYTE* WINPR_RESTRICT pDst2[3],
1539 const UINT32 dst2Step[3],
1540 const prim_size_t* WINPR_RESTRICT roi)
1541{
1546 size_t y = 0;
1547 for (; y < roi->height - roi->height % 2; y += 2)
1548 {
1549 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1550 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1551 const size_t i = y >> 1;
1552 const size_t n = (i & (uint32_t)~7) + i;
1553 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1554 BYTE* b1Odd = (b1Even + dst1Step[0]);
1555 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1556 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1557 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1558 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1559 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1560 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1561 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4,
1562 b5, b6, b7, roi->width);
1563 }
1564 for (; y < roi->height; y++)
1565 {
1566 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1567 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1568 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1569 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1570 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1571 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1572 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, nullptr, b1Even, nullptr, b2, b3,
1573 nullptr, nullptr, b6, b7, roi->width);
1574 }
1575
1576 return PRIMITIVES_SUCCESS;
1577}
1578
1579static inline void general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(
1580 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
1581 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1582 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1583 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1584{
1585 for (UINT32 x = 0; x < width; x += 2)
1586 {
1587 const BOOL lastX = (x + 1) >= width;
1588 BYTE Y1e = 0;
1589 BYTE Y2e = 0;
1590 BYTE U1e = 0;
1591 BYTE V1e = 0;
1592 BYTE U2e = 0;
1593 BYTE V2e = 0;
1594 BYTE Y1o = 0;
1595 BYTE Y2o = 0;
1596 BYTE U1o = 0;
1597 BYTE V1o = 0;
1598 BYTE U2o = 0;
1599 BYTE V2o = 0;
1600 /* Read 4 pixels, 2 from even, 2 from odd lines */
1601 {
1602 const BYTE r = *srcEven++;
1603 const BYTE g = *srcEven++;
1604 const BYTE b = *srcEven++;
1605 srcEven++;
1606 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1607 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1608 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1609 }
1610
1611 if (!lastX)
1612 {
1613 const BYTE r = *srcEven++;
1614 const BYTE g = *srcEven++;
1615 const BYTE b = *srcEven++;
1616 srcEven++;
1617 Y2e = RGB2Y(r, g, b);
1618 U2e = RGB2U(r, g, b);
1619 V2e = RGB2V(r, g, b);
1620 }
1621
1622 if (b1Odd)
1623 {
1624 const BYTE r = *srcOdd++;
1625 const BYTE g = *srcOdd++;
1626 const BYTE b = *srcOdd++;
1627 srcOdd++;
1628 Y1o = Y2o = RGB2Y(r, g, b);
1629 U1o = U2o = RGB2U(r, g, b);
1630 V1o = V2o = RGB2V(r, g, b);
1631 }
1632
1633 if (b1Odd && !lastX)
1634 {
1635 const BYTE r = *srcOdd++;
1636 const BYTE g = *srcOdd++;
1637 const BYTE b = *srcOdd++;
1638 srcOdd++;
1639 Y2o = RGB2Y(r, g, b);
1640 U2o = RGB2U(r, g, b);
1641 V2o = RGB2V(r, g, b);
1642 }
1643
1644 /* We have 4 Y pixels, so store them. */
1645 *b1Even++ = Y1e;
1646 *b1Even++ = Y2e;
1647
1648 if (b1Odd)
1649 {
1650 *b1Odd++ = Y1o;
1651 *b1Odd++ = Y2o;
1652 }
1653
1654 /* 2x 2y pixel in luma UV plane use averaging
1655 */
1656 {
1657 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1658 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1659 *b2++ = Uavg;
1660 *b3++ = Vavg;
1661 }
1662
1663 /* UV from 2x, 2y+1 */
1664 if (b1Odd)
1665 {
1666 *b4++ = U1o;
1667 *b5++ = V1o;
1668
1669 if (!lastX)
1670 {
1671 *b4++ = U2o;
1672 *b5++ = V2o;
1673 }
1674 }
1675
1676 /* UV from 2x+1, 2y */
1677 if (!lastX)
1678 {
1679 *b6++ = U2e;
1680 *b7++ = V2e;
1681 }
1682 }
1683}
1684
1685static inline pstatus_t general_RGBToAVC444YUV_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1686 BYTE* WINPR_RESTRICT pDst1[3],
1687 const UINT32 dst1Step[3],
1688 BYTE* WINPR_RESTRICT pDst2[3],
1689 const UINT32 dst2Step[3],
1690 const prim_size_t* WINPR_RESTRICT roi)
1691{
1697 size_t y = 0;
1698 for (; y < roi->height - roi->height % 2; y += 2)
1699 {
1700 const BOOL last = (y >= (roi->height - 1));
1701 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1702 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1703 const size_t i = y >> 1;
1704 const size_t n = (i & (size_t)~7) + i;
1705 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1706 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : nullptr;
1707 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1708 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1709 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1710 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1711 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1712 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1713 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5, b6,
1714 b7, roi->width);
1715 }
1716 for (; y < roi->height; y++)
1717 {
1718 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1719 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1720 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1721 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1722 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1723 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1724 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, nullptr, b1Even, nullptr, b2, b3, nullptr,
1725 nullptr, b6, b7, roi->width);
1726 }
1727 return PRIMITIVES_SUCCESS;
1728}
1729
1730static inline void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(
1731 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1732 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1733 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1734 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1735{
1736 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1737 for (UINT32 x = 0; x < width; x += 2)
1738 {
1739 const BOOL lastX = (x + 1) >= width;
1740 BYTE Y1e = 0;
1741 BYTE Y2e = 0;
1742 BYTE U1e = 0;
1743 BYTE V1e = 0;
1744 BYTE U2e = 0;
1745 BYTE V2e = 0;
1746 BYTE Y1o = 0;
1747 BYTE Y2o = 0;
1748 BYTE U1o = 0;
1749 BYTE V1o = 0;
1750 BYTE U2o = 0;
1751 BYTE V2o = 0;
1752 /* Read 4 pixels, 2 from even, 2 from odd lines */
1753 {
1754 BYTE r = 0;
1755 BYTE g = 0;
1756 BYTE b = 0;
1757 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1758 srcEven += bpp;
1759 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1760 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1761 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1762 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1763 }
1764
1765 if (!lastX)
1766 {
1767 BYTE r = 0;
1768 BYTE g = 0;
1769 BYTE b = 0;
1770 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1771 srcEven += bpp;
1772 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1773 Y2e = RGB2Y(r, g, b);
1774 U2e = RGB2U(r, g, b);
1775 V2e = RGB2V(r, g, b);
1776 }
1777
1778 if (b1Odd)
1779 {
1780 BYTE r = 0;
1781 BYTE g = 0;
1782 BYTE b = 0;
1783 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1784 srcOdd += bpp;
1785 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1786 Y1o = Y2o = RGB2Y(r, g, b);
1787 U1o = U2o = RGB2U(r, g, b);
1788 V1o = V2o = RGB2V(r, g, b);
1789 }
1790
1791 if (b1Odd && !lastX)
1792 {
1793 BYTE r = 0;
1794 BYTE g = 0;
1795 BYTE b = 0;
1796 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1797 srcOdd += bpp;
1798 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1799 Y2o = RGB2Y(r, g, b);
1800 U2o = RGB2U(r, g, b);
1801 V2o = RGB2V(r, g, b);
1802 }
1803
1804 /* We have 4 Y pixels, so store them. */
1805 *b1Even++ = Y1e;
1806 *b1Even++ = Y2e;
1807
1808 if (b1Odd)
1809 {
1810 *b1Odd++ = Y1o;
1811 *b1Odd++ = Y2o;
1812 }
1813
1814 /* 2x 2y pixel in luma UV plane use averaging
1815 */
1816 {
1817 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(
1818 BYTE, ((UINT16)U1e + (UINT16)U2e + (UINT16)U1o + (UINT16)U2o) / 4);
1819 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(
1820 BYTE, ((UINT16)V1e + (UINT16)V2e + (UINT16)V1o + (UINT16)V2o) / 4);
1821 *b2++ = Uavg;
1822 *b3++ = Vavg;
1823 }
1824
1825 /* UV from 2x, 2y+1 */
1826 if (b1Odd)
1827 {
1828 *b4++ = U1o;
1829 *b5++ = V1o;
1830
1831 if (!lastX)
1832 {
1833 *b4++ = U2o;
1834 *b5++ = V2o;
1835 }
1836 }
1837
1838 /* UV from 2x+1, 2y */
1839 if (!lastX)
1840 {
1841 *b6++ = U2e;
1842 *b7++ = V2e;
1843 }
1844 }
1845}
1846
1847static inline pstatus_t
1848general_RGBToAVC444YUV_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
1849 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
1850 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
1851 const prim_size_t* WINPR_RESTRICT roi)
1852{
1910 const BYTE* pMaxSrc = pSrc + 1ULL * (roi->height - 1) * srcStep;
1911
1912 for (size_t y = 0; y < roi->height; y += 2)
1913 {
1914 WINPR_ASSERT(y < UINT32_MAX);
1915
1916 const BOOL last = (y >= (roi->height - 1));
1917 const BYTE* srcEven = y < roi->height ? pSrc + y * srcStep : pMaxSrc;
1918 const BYTE* srcOdd = !last ? pSrc + (y + 1) * srcStep : pMaxSrc;
1919 const UINT32 i = (UINT32)y >> 1;
1920 const UINT32 n = (i & (uint32_t)~7) + i;
1921 BYTE* b1Even = pDst1[0] + y * dst1Step[0];
1922 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : nullptr;
1923 BYTE* b2 = pDst1[1] + (y / 2) * dst1Step[1];
1924 BYTE* b3 = pDst1[2] + (y / 2) * dst1Step[2];
1925 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1926 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1927 BYTE* b6 = pDst2[1] + (y / 2) * dst2Step[1];
1928 BYTE* b7 = pDst2[2] + (y / 2) * dst2Step[2];
1929 general_RGBToAVC444YUV_ANY_DOUBLE_ROW(srcEven, srcOdd, srcFormat, b1Even, b1Odd, b2, b3, b4,
1930 b5, b6, b7, roi->width);
1931 }
1932
1933 return PRIMITIVES_SUCCESS;
1934}
1935
1936static inline pstatus_t general_RGBToAVC444YUV(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1937 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
1938 const UINT32 dst1Step[3],
1939 BYTE* WINPR_RESTRICT pDst2[3],
1940 const UINT32 dst2Step[3],
1941 const prim_size_t* WINPR_RESTRICT roi)
1942{
1943 if (!pSrc || !pDst1 || !dst1Step || !pDst2 || !dst2Step)
1944 return -1;
1945
1946 if (!pDst1[0] || !pDst1[1] || !pDst1[2])
1947 return -1;
1948
1949 if (!dst1Step[0] || !dst1Step[1] || !dst1Step[2])
1950 return -1;
1951
1952 if (!pDst2[0] || !pDst2[1] || !pDst2[2])
1953 return -1;
1954
1955 if (!dst2Step[0] || !dst2Step[1] || !dst2Step[2])
1956 return -1;
1957
1958 switch (srcFormat)
1959 {
1960
1961 case PIXEL_FORMAT_BGRA32:
1962 case PIXEL_FORMAT_BGRX32:
1963 return general_RGBToAVC444YUV_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1964 roi);
1965
1966 case PIXEL_FORMAT_RGBA32:
1967 case PIXEL_FORMAT_RGBX32:
1968 return general_RGBToAVC444YUV_RGBX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1969 roi);
1970
1971 default:
1972 return general_RGBToAVC444YUV_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
1973 dst2Step, roi);
1974 }
1975
1976 return !PRIMITIVES_SUCCESS;
1977}
1978
1979static inline void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
1980 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1981 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
1982 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
1983 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
1984 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
1985 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
1986 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
1987{
1988 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1989
1990 for (UINT32 x = 0; x < width; x += 2)
1991 {
1992 BYTE Ya = 0;
1993 BYTE Ua = 0;
1994 BYTE Va = 0;
1995 BYTE Yb = 0;
1996 BYTE Ub = 0;
1997 BYTE Vb = 0;
1998 BYTE Yc = 0;
1999 BYTE Uc = 0;
2000 BYTE Vc = 0;
2001 BYTE Yd = 0;
2002 BYTE Ud = 0;
2003 BYTE Vd = 0;
2004 {
2005 BYTE b = 0;
2006 BYTE g = 0;
2007 BYTE r = 0;
2008 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
2009 srcEven += bpp;
2010 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
2011 Ya = RGB2Y(r, g, b);
2012 Ua = RGB2U(r, g, b);
2013 Va = RGB2V(r, g, b);
2014 }
2015
2016 if (x < width - 1)
2017 {
2018 BYTE b = 0;
2019 BYTE g = 0;
2020 BYTE r = 0;
2021 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
2022 srcEven += bpp;
2023 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
2024 Yb = RGB2Y(r, g, b);
2025 Ub = RGB2U(r, g, b);
2026 Vb = RGB2V(r, g, b);
2027 }
2028 else
2029 {
2030 Yb = Ya;
2031 Ub = Ua;
2032 Vb = Va;
2033 }
2034
2035 if (srcOdd)
2036 {
2037 BYTE b = 0;
2038 BYTE g = 0;
2039 BYTE r = 0;
2040 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
2041 srcOdd += bpp;
2042 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
2043 Yc = RGB2Y(r, g, b);
2044 Uc = RGB2U(r, g, b);
2045 Vc = RGB2V(r, g, b);
2046 }
2047 else
2048 {
2049 Yc = Ya;
2050 Uc = Ua;
2051 Vc = Va;
2052 }
2053
2054 if (srcOdd && (x < width - 1))
2055 {
2056 BYTE b = 0;
2057 BYTE g = 0;
2058 BYTE r = 0;
2059 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
2060 srcOdd += bpp;
2061 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
2062 Yd = RGB2Y(r, g, b);
2063 Ud = RGB2U(r, g, b);
2064 Vd = RGB2V(r, g, b);
2065 }
2066 else
2067 {
2068 Yd = Ya;
2069 Ud = Ua;
2070 Vd = Va;
2071 }
2072
2073 /* Y [b1] */
2074 *yLumaDstEven++ = Ya;
2075
2076 if (x < width - 1)
2077 *yLumaDstEven++ = Yb;
2078
2079 if (srcOdd)
2080 *yLumaDstOdd++ = Yc;
2081
2082 if (srcOdd && (x < width - 1))
2083 *yLumaDstOdd++ = Yd;
2084
2085 /* 2x 2y [b2,b3] */
2086 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2087 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2088
2089 /* 2x+1, y [b4,b5] even */
2090 if (x < width - 1)
2091 {
2092 *yEvenChromaDst1++ = Ub;
2093 *yEvenChromaDst2++ = Vb;
2094 }
2095
2096 if (srcOdd)
2097 {
2098 /* 2x+1, y [b4,b5] odd */
2099 if (x < width - 1)
2100 {
2101 *yOddChromaDst1++ = Ud;
2102 *yOddChromaDst2++ = Vd;
2103 }
2104
2105 /* 4x 2y+1 [b6, b7] */
2106 if (x % 4 == 0)
2107 {
2108 *uChromaDst1++ = Uc;
2109 *uChromaDst2++ = Vc;
2110 }
2111 /* 4x+2 2y+1 [b8, b9] */
2112 else
2113 {
2114 *vChromaDst1++ = Uc;
2115 *vChromaDst2++ = Vc;
2116 }
2117 }
2118 }
2119}
2120
2121static inline pstatus_t
2122general_RGBToAVC444YUVv2_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
2123 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
2124 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
2125 const prim_size_t* WINPR_RESTRICT roi)
2126{
2177 if (roi->height < 1 || roi->width < 1)
2178 return !PRIMITIVES_SUCCESS;
2179
2180 size_t y = 0;
2181 for (; y < roi->height - roi->height % 2; y += 2)
2182 {
2183 const BYTE* srcEven = (pSrc + y * srcStep);
2184 const BYTE* srcOdd = (y < roi->height - 1) ? (srcEven + srcStep) : nullptr;
2185 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2186 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2187 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2188 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2189 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2190 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2191 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2192 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2193 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2194 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2195 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2196 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2197 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2198 srcEven, srcOdd, srcFormat, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV,
2199 dstEvenChromaY1, dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1,
2200 dstChromaU2, dstChromaV1, dstChromaV2, roi->width);
2201 }
2202 for (; y < roi->height; y++)
2203 {
2204 const BYTE* srcEven = (pSrc + y * srcStep);
2205 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2206 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2207 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2208 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2209 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2210 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2211 srcEven, nullptr, srcFormat, dstLumaYEven, nullptr, dstLumaU, dstLumaV, dstEvenChromaY1,
2212 dstEvenChromaY2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, roi->width);
2213 }
2214
2215 return PRIMITIVES_SUCCESS;
2216}
2217
2218static inline void int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2219 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2220 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2221 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2222 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2223 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2224 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2225 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2226{
2227 WINPR_ASSERT(pSrcEven);
2228 WINPR_ASSERT(yLumaDstEven);
2229 WINPR_ASSERT(uLumaDst);
2230 WINPR_ASSERT(vLumaDst);
2231
2232 for (size_t x = offset; x < width; x += 2)
2233 {
2234 const BYTE* srcEven = &pSrcEven[4ULL * x];
2235 const BYTE* srcOdd = pSrcOdd ? &pSrcOdd[4ULL * x] : nullptr;
2236 BYTE Ya = 0;
2237 BYTE Ua = 0;
2238 BYTE Va = 0;
2239 BYTE Yb = 0;
2240 BYTE Ub = 0;
2241 BYTE Vb = 0;
2242 BYTE Yc = 0;
2243 BYTE Uc = 0;
2244 BYTE Vc = 0;
2245 BYTE Yd = 0;
2246 BYTE Ud = 0;
2247 BYTE Vd = 0;
2248 {
2249 const BYTE b = *srcEven++;
2250 const BYTE g = *srcEven++;
2251 const BYTE r = *srcEven++;
2252 srcEven++;
2253 Ya = RGB2Y(r, g, b);
2254 Ua = RGB2U(r, g, b);
2255 Va = RGB2V(r, g, b);
2256 }
2257
2258 if (x < width - 1)
2259 {
2260 const BYTE b = *srcEven++;
2261 const BYTE g = *srcEven++;
2262 const BYTE r = *srcEven++;
2263 srcEven++;
2264 Yb = RGB2Y(r, g, b);
2265 Ub = RGB2U(r, g, b);
2266 Vb = RGB2V(r, g, b);
2267 }
2268 else
2269 {
2270 Yb = Ya;
2271 Ub = Ua;
2272 Vb = Va;
2273 }
2274
2275 if (srcOdd)
2276 {
2277 const BYTE b = *srcOdd++;
2278 const BYTE g = *srcOdd++;
2279 const BYTE r = *srcOdd++;
2280 srcOdd++;
2281 Yc = RGB2Y(r, g, b);
2282 Uc = RGB2U(r, g, b);
2283 Vc = RGB2V(r, g, b);
2284 }
2285 else
2286 {
2287 Yc = Ya;
2288 Uc = Ua;
2289 Vc = Va;
2290 }
2291
2292 if (srcOdd && (x < width - 1))
2293 {
2294 const BYTE b = *srcOdd++;
2295 const BYTE g = *srcOdd++;
2296 const BYTE r = *srcOdd++;
2297 srcOdd++;
2298 Yd = RGB2Y(r, g, b);
2299 Ud = RGB2U(r, g, b);
2300 Vd = RGB2V(r, g, b);
2301 }
2302 else
2303 {
2304 Yd = Ya;
2305 Ud = Ua;
2306 Vd = Va;
2307 }
2308
2309 /* Y [b1] */
2310 *yLumaDstEven++ = Ya;
2311
2312 if (x < width - 1)
2313 *yLumaDstEven++ = Yb;
2314
2315 if (srcOdd && yLumaDstOdd)
2316 *yLumaDstOdd++ = Yc;
2317
2318 if (srcOdd && (x < width - 1) && yLumaDstOdd)
2319 *yLumaDstOdd++ = Yd;
2320
2321 /* 2x 2y [b2,b3] */
2322 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2323 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2324
2325 /* 2x+1, y [b4,b5] even */
2326 if (x < width - 1)
2327 {
2328 *yEvenChromaDst1++ = Ub;
2329 *yEvenChromaDst2++ = Vb;
2330 }
2331
2332 if (srcOdd)
2333 {
2334 /* 2x+1, y [b4,b5] odd */
2335 if (x < width - 1)
2336 {
2337 *yOddChromaDst1++ = Ud;
2338 *yOddChromaDst2++ = Vd;
2339 }
2340
2341 /* 4x 2y+1 [b6, b7] */
2342 if (x % 4 == 0)
2343 {
2344 *uChromaDst1++ = Uc;
2345 *uChromaDst2++ = Vc;
2346 }
2347 /* 4x+2 2y+1 [b8, b9] */
2348 else
2349 {
2350 *vChromaDst1++ = Uc;
2351 *vChromaDst2++ = Vc;
2352 }
2353 }
2354 }
2355}
2356
2357void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2358 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2359 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2360 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2361 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2362 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2363 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2364 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2365{
2366 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2367 offset, pSrcEven, pSrcOdd, yLumaDstEven, yLumaDstOdd, uLumaDst, vLumaDst, yEvenChromaDst1,
2368 yEvenChromaDst2, yOddChromaDst1, yOddChromaDst2, uChromaDst1, uChromaDst2, vChromaDst1,
2369 vChromaDst2, width);
2370}
2371
2372static inline pstatus_t general_RGBToAVC444YUVv2_BGRX(const BYTE* WINPR_RESTRICT pSrc,
2373 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2374 const UINT32 dst1Step[3],
2375 BYTE* WINPR_RESTRICT pDst2[3],
2376 const UINT32 dst2Step[3],
2377 const prim_size_t* WINPR_RESTRICT roi)
2378{
2379 if (roi->height < 1 || roi->width < 1)
2380 return !PRIMITIVES_SUCCESS;
2381
2382 size_t y = 0;
2383 for (; y < roi->height - roi->height % 2; y += 2)
2384 {
2385 const BYTE* srcEven = (pSrc + y * srcStep);
2386 const BYTE* srcOdd = (srcEven + srcStep);
2387 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2388 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2389 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2390 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2391 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2392 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2393 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2394 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2395 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2396 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2397 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2398 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2399 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2400 0, srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
2401 dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1, dstChromaU2, dstChromaV1,
2402 dstChromaV2, roi->width);
2403 }
2404 for (; y < roi->height; y++)
2405 {
2406 const BYTE* srcEven = (pSrc + y * srcStep);
2407 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2408 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2409 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2410 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2411 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2412 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2413 0, srcEven, nullptr, dstLumaYEven, nullptr, dstLumaU, dstLumaV, dstEvenChromaY1,
2414 dstEvenChromaY2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, roi->width);
2415 }
2416
2417 return PRIMITIVES_SUCCESS;
2418}
2419
2420static pstatus_t general_RGBToAVC444YUVv2(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
2421 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2422 const UINT32 dst1Step[3], BYTE* WINPR_RESTRICT pDst2[3],
2423 const UINT32 dst2Step[3],
2424 const prim_size_t* WINPR_RESTRICT roi)
2425{
2426 switch (srcFormat)
2427 {
2428 case PIXEL_FORMAT_BGRA32:
2429 case PIXEL_FORMAT_BGRX32:
2430 return general_RGBToAVC444YUVv2_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
2431 roi);
2432
2433 default:
2434 return general_RGBToAVC444YUVv2_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
2435 dst2Step, roi);
2436 }
2437
2438 return !PRIMITIVES_SUCCESS;
2439}
2440
2441void primitives_init_YUV(primitives_t* WINPR_RESTRICT prims)
2442{
2443 prims->YUV420ToRGB_8u_P3AC4R = general_YUV420ToRGB_8u_P3AC4R;
2444 prims->YUV444ToRGB_8u_P3AC4R = general_YUV444ToRGB_8u_P3AC4R;
2445 prims->RGBToYUV420_8u_P3AC4R = general_RGBToYUV420_8u_P3AC4R;
2446 prims->RGBToYUV444_8u_P3AC4R = general_RGBToYUV444_8u_P3AC4R;
2447 prims->RGBToI444_8u = general_RGBToI444_8u;
2448 prims->I444ToRGB_8u = general_I444ToRGB_8u;
2449 prims->YUV420CombineToYUV444 = general_YUV420CombineToYUV444;
2450 prims->YUV444SplitToYUV420 = general_YUV444SplitToYUV420;
2451 prims->RGBToAVC444YUV = general_RGBToAVC444YUV;
2452 prims->RGBToAVC444YUVv2 = general_RGBToAVC444YUVv2;
2453}
2454
2455void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims)
2456{
2457 primitives_init_YUV(prims);
2458 primitives_init_YUV_sse41(prims);
2459 primitives_init_YUV_avx2(prims);
2460 primitives_init_YUV_neon(prims);
2461}
RECTANGLE_16
Definition types.h:109
prim_size_t
Definition primitives.h:74
primitives_t
Definition primitives.h:255