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
974static pstatus_t general_RGBToI444_8u(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,
975 const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
976 const UINT32 dstStep[3],
977 const prim_size_t* WINPR_RESTRICT roi)
978{
979 switch (SrcFormat)
980 {
981 default:
982 return general_RGBToI444_8u_RGB(pSrc, SrcFormat, srcStep, pDst, dstStep, roi);
983 }
984}
985
986static inline pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
987 BYTE* WINPR_RESTRICT pDst[3],
988 const UINT32 dstStep[3],
989 const prim_size_t* WINPR_RESTRICT roi)
990{
991 size_t x1 = 0;
992 size_t x2 = 4;
993 size_t x3 = srcStep;
994 size_t x4 = srcStep + 4;
995 size_t y1 = 0;
996 size_t y2 = 1;
997 size_t y3 = dstStep[0];
998 size_t y4 = dstStep[0] + 1;
999 UINT32 max_x = roi->width - 1;
1000
1001 size_t y = 0;
1002 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1003 {
1004 const BYTE* src = pSrc + y * srcStep;
1005 BYTE* ydst = pDst[0] + y * dstStep[0];
1006 BYTE* udst = pDst[1] + i * dstStep[1];
1007 BYTE* vdst = pDst[2] + i * dstStep[2];
1008
1009 for (size_t x = 0; x < roi->width; x += 2)
1010 {
1011 BYTE R = 0;
1012 BYTE G = 0;
1013 BYTE B = 0;
1014 INT32 Ra = 0;
1015 INT32 Ga = 0;
1016 INT32 Ba = 0;
1017 /* row 1, pixel 1 */
1018 Ba = B = *(src + x1 + 0);
1019 Ga = G = *(src + x1 + 1);
1020 Ra = R = *(src + x1 + 2);
1021 ydst[y1] = RGB2Y(R, G, B);
1022
1023 if (x < max_x)
1024 {
1025 /* row 1, pixel 2 */
1026 Ba += B = *(src + x2 + 0);
1027 Ga += G = *(src + x2 + 1);
1028 Ra += R = *(src + x2 + 2);
1029 ydst[y2] = RGB2Y(R, G, B);
1030 }
1031
1032 /* row 2, pixel 1 */
1033 Ba += B = *(src + x3 + 0);
1034 Ga += G = *(src + x3 + 1);
1035 Ra += R = *(src + x3 + 2);
1036 ydst[y3] = RGB2Y(R, G, B);
1037
1038 if (x < max_x)
1039 {
1040 /* row 2, pixel 2 */
1041 Ba += B = *(src + x4 + 0);
1042 Ga += G = *(src + x4 + 1);
1043 Ra += R = *(src + x4 + 2);
1044 ydst[y4] = RGB2Y(R, G, B);
1045 }
1046
1047 Ba >>= 2;
1048 Ga >>= 2;
1049 Ra >>= 2;
1050 *udst++ = RGB2U(Ra, Ga, Ba);
1051 *vdst++ = RGB2V(Ra, Ga, Ba);
1052 ydst += 2;
1053 src += 8;
1054 }
1055 }
1056
1057 for (; y < roi->height; y++)
1058 {
1059 const BYTE* src = pSrc + y * srcStep;
1060 BYTE* ydst = pDst[0] + y * dstStep[0];
1061 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1062 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1063
1064 for (size_t x = 0; x < roi->width; x += 2)
1065 {
1066 BYTE R = 0;
1067 BYTE G = 0;
1068 BYTE B = 0;
1069 INT32 Ra = 0;
1070 INT32 Ga = 0;
1071 INT32 Ba = 0;
1072 /* row 1, pixel 1 */
1073 Ba = B = *(src + x1 + 0);
1074 Ga = G = *(src + x1 + 1);
1075 Ra = R = *(src + x1 + 2);
1076 ydst[y1] = RGB2Y(R, G, B);
1077
1078 if (x < max_x)
1079 {
1080 /* row 1, pixel 2 */
1081 Ba += B = *(src + x2 + 0);
1082 Ga += G = *(src + x2 + 1);
1083 Ra += R = *(src + x2 + 2);
1084 ydst[y2] = RGB2Y(R, G, B);
1085 }
1086
1087 Ba >>= 2;
1088 Ga >>= 2;
1089 Ra >>= 2;
1090 *udst++ = RGB2U(Ra, Ga, Ba);
1091 *vdst++ = RGB2V(Ra, Ga, Ba);
1092 ydst += 2;
1093 src += 8;
1094 }
1095 }
1096
1097 return PRIMITIVES_SUCCESS;
1098}
1099
1100static inline pstatus_t general_RGBToYUV420_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1101 BYTE* WINPR_RESTRICT pDst[3],
1102 const UINT32 dstStep[3],
1103 const prim_size_t* WINPR_RESTRICT roi)
1104{
1105 size_t x1 = 0;
1106 size_t x2 = 4;
1107 size_t x3 = srcStep;
1108 size_t x4 = srcStep + 4;
1109 size_t y1 = 0;
1110 size_t y2 = 1;
1111 size_t y3 = dstStep[0];
1112 size_t y4 = dstStep[0] + 1;
1113 UINT32 max_x = roi->width - 1;
1114
1115 size_t y = 0;
1116 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1117 {
1118 const BYTE* src = pSrc + y * srcStep;
1119 BYTE* ydst = pDst[0] + y * dstStep[0];
1120 BYTE* udst = pDst[1] + i * dstStep[1];
1121 BYTE* vdst = pDst[2] + i * dstStep[2];
1122
1123 for (UINT32 x = 0; x < roi->width; x += 2)
1124 {
1125 BYTE R = *(src + x1 + 0);
1126 BYTE G = *(src + x1 + 1);
1127 BYTE B = *(src + x1 + 2);
1128 /* row 1, pixel 1 */
1129 INT32 Ra = R;
1130 INT32 Ga = G;
1131 INT32 Ba = B;
1132 ydst[y1] = RGB2Y(R, G, B);
1133
1134 if (x < max_x)
1135 {
1136 /* row 1, pixel 2 */
1137 R = *(src + x2 + 0);
1138 G = *(src + x2 + 1);
1139 B = *(src + x2 + 2);
1140 Ra += R;
1141 Ga += G;
1142 Ba += B;
1143 ydst[y2] = RGB2Y(R, G, B);
1144 }
1145
1146 /* row 2, pixel 1 */
1147 R = *(src + x3 + 0);
1148 G = *(src + x3 + 1);
1149 B = *(src + x3 + 2);
1150
1151 Ra += R;
1152 Ga += G;
1153 Ba += B;
1154 ydst[y3] = RGB2Y(R, G, B);
1155
1156 if (x < max_x)
1157 {
1158 /* row 2, pixel 2 */
1159 R = *(src + x4 + 0);
1160 G = *(src + x4 + 1);
1161 B = *(src + x4 + 2);
1162
1163 Ra += R;
1164 Ga += G;
1165 Ba += B;
1166 ydst[y4] = RGB2Y(R, G, B);
1167 }
1168
1169 Ba >>= 2;
1170 Ga >>= 2;
1171 Ra >>= 2;
1172 *udst++ = RGB2U(Ra, Ga, Ba);
1173 *vdst++ = RGB2V(Ra, Ga, Ba);
1174 ydst += 2;
1175 src += 8;
1176 }
1177 }
1178
1179 for (; y < roi->height; y++)
1180 {
1181 const BYTE* src = pSrc + y * srcStep;
1182 BYTE* ydst = pDst[0] + y * dstStep[0];
1183 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1184 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1185
1186 for (UINT32 x = 0; x < roi->width; x += 2)
1187 {
1188 BYTE R = *(src + x1 + 0);
1189 BYTE G = *(src + x1 + 1);
1190 BYTE B = *(src + x1 + 2);
1191 /* row 1, pixel 1 */
1192 INT32 Ra = R;
1193 INT32 Ga = G;
1194 INT32 Ba = B;
1195 ydst[y1] = RGB2Y(R, G, B);
1196
1197 if (x < max_x)
1198 {
1199 /* row 1, pixel 2 */
1200 R = *(src + x2 + 0);
1201 G = *(src + x2 + 1);
1202 B = *(src + x2 + 2);
1203 Ra += R;
1204 Ga += G;
1205 Ba += B;
1206 ydst[y2] = RGB2Y(R, G, B);
1207 }
1208
1209 Ba >>= 2;
1210 Ga >>= 2;
1211 Ra >>= 2;
1212 *udst++ = RGB2U(Ra, Ga, Ba);
1213 *vdst++ = RGB2V(Ra, Ga, Ba);
1214 ydst += 2;
1215 src += 8;
1216 }
1217 }
1218
1219 return PRIMITIVES_SUCCESS;
1220}
1221
1222static inline pstatus_t general_RGBToYUV420_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1223 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1224 const UINT32 dstStep[3],
1225 const prim_size_t* WINPR_RESTRICT roi)
1226{
1227 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1228 size_t x1 = 0;
1229 size_t x2 = bpp;
1230 size_t x3 = srcStep;
1231 size_t x4 = srcStep + bpp;
1232 size_t y1 = 0;
1233 size_t y2 = 1;
1234 size_t y3 = dstStep[0];
1235 size_t y4 = dstStep[0] + 1;
1236 UINT32 max_x = roi->width - 1;
1237
1238 size_t y = 0;
1239 for (size_t i = 0; y < roi->height - roi->height % 2; y += 2, i++)
1240 {
1241 const BYTE* src = pSrc + y * srcStep;
1242 BYTE* ydst = pDst[0] + y * dstStep[0];
1243 BYTE* udst = pDst[1] + i * dstStep[1];
1244 BYTE* vdst = pDst[2] + i * dstStep[2];
1245
1246 for (size_t x = 0; x < roi->width; x += 2)
1247 {
1248 BYTE R = 0;
1249 BYTE G = 0;
1250 BYTE B = 0;
1251 INT32 Ra = 0;
1252 INT32 Ga = 0;
1253 INT32 Ba = 0;
1254 UINT32 color = 0;
1255 /* row 1, pixel 1 */
1256 color = FreeRDPReadColor(src + x1, srcFormat);
1257 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1258 Ra = R;
1259 Ga = G;
1260 Ba = B;
1261 ydst[y1] = RGB2Y(R, G, B);
1262
1263 if (x < max_x)
1264 {
1265 /* row 1, pixel 2 */
1266 color = FreeRDPReadColor(src + x2, srcFormat);
1267 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1268 Ra += R;
1269 Ga += G;
1270 Ba += B;
1271 ydst[y2] = RGB2Y(R, G, B);
1272 }
1273
1274 /* row 2, pixel 1 */
1275 color = FreeRDPReadColor(src + x3, srcFormat);
1276 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1277 Ra += R;
1278 Ga += G;
1279 Ba += B;
1280 ydst[y3] = RGB2Y(R, G, B);
1281
1282 if (x < max_x)
1283 {
1284 /* row 2, pixel 2 */
1285 color = FreeRDPReadColor(src + x4, srcFormat);
1286 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1287 Ra += R;
1288 Ga += G;
1289 Ba += B;
1290 ydst[y4] = RGB2Y(R, G, B);
1291 }
1292
1293 Ra >>= 2;
1294 Ga >>= 2;
1295 Ba >>= 2;
1296 *udst++ = RGB2U(Ra, Ga, Ba);
1297 *vdst++ = RGB2V(Ra, Ga, Ba);
1298 ydst += 2;
1299 src += 2ULL * bpp;
1300 }
1301 }
1302
1303 for (; y < roi->height; y++)
1304 {
1305 const BYTE* src = pSrc + y * srcStep;
1306 BYTE* ydst = pDst[0] + y * dstStep[0];
1307 BYTE* udst = pDst[1] + (y / 2) * dstStep[1];
1308 BYTE* vdst = pDst[2] + (y / 2) * dstStep[2];
1309
1310 for (size_t x = 0; x < roi->width; x += 2)
1311 {
1312 BYTE R = 0;
1313 BYTE G = 0;
1314 BYTE B = 0;
1315 /* row 1, pixel 1 */
1316 UINT32 color = FreeRDPReadColor(src + x1, srcFormat);
1317 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1318 INT32 Ra = R;
1319 INT32 Ga = G;
1320 INT32 Ba = B;
1321 ydst[y1] = RGB2Y(R, G, B);
1322
1323 if (x < max_x)
1324 {
1325 /* row 1, pixel 2 */
1326 color = FreeRDPReadColor(src + x2, srcFormat);
1327 FreeRDPSplitColor(color, srcFormat, &R, &G, &B, nullptr, nullptr);
1328 Ra += R;
1329 Ga += G;
1330 Ba += B;
1331 ydst[y2] = RGB2Y(R, G, B);
1332 }
1333
1334 Ra >>= 2;
1335 Ga >>= 2;
1336 Ba >>= 2;
1337 *udst++ = RGB2U(Ra, Ga, Ba);
1338 *vdst++ = RGB2V(Ra, Ga, Ba);
1339 ydst += 2;
1340 src += 2ULL * bpp;
1341 }
1342 }
1343
1344 return PRIMITIVES_SUCCESS;
1345}
1346
1347static pstatus_t general_RGBToYUV420_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1348 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],
1349 const UINT32 dstStep[3],
1350 const prim_size_t* WINPR_RESTRICT roi)
1351{
1352 switch (srcFormat)
1353 {
1354 case PIXEL_FORMAT_BGRA32:
1355 case PIXEL_FORMAT_BGRX32:
1356 return general_RGBToYUV420_BGRX(pSrc, srcStep, pDst, dstStep, roi);
1357
1358 case PIXEL_FORMAT_RGBA32:
1359 case PIXEL_FORMAT_RGBX32:
1360 return general_RGBToYUV420_RGBX(pSrc, srcStep, pDst, dstStep, roi);
1361
1362 default:
1363 return general_RGBToYUV420_ANY(pSrc, srcFormat, srcStep, pDst, dstStep, roi);
1364 }
1365}
1366
1367static inline void int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(
1368 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
1369 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1370 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1371 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1372{
1373 for (size_t x = offset; x < width; x += 2)
1374 {
1375 const BYTE* srcEven = &pSrcEven[4ULL * x];
1376 const BYTE* srcOdd = &pSrcOdd[4ULL * x];
1377 const BOOL lastX = (x + 1) >= width;
1378 BYTE Y1e = 0;
1379 BYTE Y2e = 0;
1380 BYTE U1e = 0;
1381 BYTE V1e = 0;
1382 BYTE U2e = 0;
1383 BYTE V2e = 0;
1384 BYTE Y1o = 0;
1385 BYTE Y2o = 0;
1386 BYTE U1o = 0;
1387 BYTE V1o = 0;
1388 BYTE U2o = 0;
1389 BYTE V2o = 0;
1390 /* Read 4 pixels, 2 from even, 2 from odd lines */
1391 {
1392 const BYTE b = *srcEven++;
1393 const BYTE g = *srcEven++;
1394 const BYTE r = *srcEven++;
1395 srcEven++;
1396 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1397 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1398 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1399 }
1400
1401 if (!lastX)
1402 {
1403 const BYTE b = *srcEven++;
1404 const BYTE g = *srcEven++;
1405 const BYTE r = *srcEven++;
1406 srcEven++;
1407 Y2e = RGB2Y(r, g, b);
1408 U2e = RGB2U(r, g, b);
1409 V2e = RGB2V(r, g, b);
1410 }
1411
1412 if (b1Odd)
1413 {
1414 const BYTE b = *srcOdd++;
1415 const BYTE g = *srcOdd++;
1416 const BYTE r = *srcOdd++;
1417 srcOdd++;
1418 Y1o = Y2o = RGB2Y(r, g, b);
1419 U1o = U2o = RGB2U(r, g, b);
1420 V1o = V2o = RGB2V(r, g, b);
1421 }
1422
1423 if (b1Odd && !lastX)
1424 {
1425 const BYTE b = *srcOdd++;
1426 const BYTE g = *srcOdd++;
1427 const BYTE r = *srcOdd++;
1428 srcOdd++;
1429 Y2o = RGB2Y(r, g, b);
1430 U2o = RGB2U(r, g, b);
1431 V2o = RGB2V(r, g, b);
1432 }
1433
1434 /* We have 4 Y pixels, so store them. */
1435 *b1Even++ = Y1e;
1436 *b1Even++ = Y2e;
1437
1438 if (b1Odd)
1439 {
1440 *b1Odd++ = Y1o;
1441 *b1Odd++ = Y2o;
1442 }
1443
1444 /* 2x 2y pixel in luma UV plane use averaging
1445 */
1446 {
1447 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1448 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1449 *b2++ = Uavg;
1450 *b3++ = Vavg;
1451 }
1452
1453 /* UV from 2x, 2y+1 */
1454 if (b1Odd)
1455 {
1456 *b4++ = U1o;
1457 *b5++ = V1o;
1458
1459 if (!lastX)
1460 {
1461 *b4++ = U2o;
1462 *b5++ = V2o;
1463 }
1464 }
1465
1466 /* UV from 2x+1, 2y */
1467 if (!lastX)
1468 {
1469 *b6++ = U2e;
1470 *b7++ = V2e;
1471 }
1472 }
1473}
1474
1475void general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(size_t offset, const BYTE* WINPR_RESTRICT pSrcEven,
1476 const BYTE* WINPR_RESTRICT pSrcOdd,
1477 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd,
1478 BYTE* WINPR_RESTRICT b2, BYTE* WINPR_RESTRICT b3,
1479 BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1480 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7,
1481 UINT32 width)
1482{
1483 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(offset, pSrcEven, pSrcOdd, b1Even, b1Odd, b2, b3, b4,
1484 b5, b6, b7, width);
1485}
1486
1487static inline pstatus_t general_RGBToAVC444YUV_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1488 BYTE* WINPR_RESTRICT pDst1[3],
1489 const UINT32 dst1Step[3],
1490 BYTE* WINPR_RESTRICT pDst2[3],
1491 const UINT32 dst2Step[3],
1492 const prim_size_t* WINPR_RESTRICT roi)
1493{
1498 size_t y = 0;
1499 for (; y < roi->height - roi->height % 2; y += 2)
1500 {
1501 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1502 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1503 const size_t i = y >> 1;
1504 const size_t n = (i & (uint32_t)~7) + i;
1505 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1506 BYTE* b1Odd = (b1Even + dst1Step[0]);
1507 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1508 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1509 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1510 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1511 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1512 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1513 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4,
1514 b5, b6, b7, roi->width);
1515 }
1516 for (; y < roi->height; y++)
1517 {
1518 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1519 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1520 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1521 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1522 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1523 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1524 int_general_RGBToAVC444YUV_BGRX_DOUBLE_ROW(0, srcEven, nullptr, b1Even, nullptr, b2, b3,
1525 nullptr, nullptr, b6, b7, roi->width);
1526 }
1527
1528 return PRIMITIVES_SUCCESS;
1529}
1530
1531static inline void general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(
1532 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd,
1533 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1534 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1535 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1536{
1537 for (UINT32 x = 0; x < width; x += 2)
1538 {
1539 const BOOL lastX = (x + 1) >= width;
1540 BYTE Y1e = 0;
1541 BYTE Y2e = 0;
1542 BYTE U1e = 0;
1543 BYTE V1e = 0;
1544 BYTE U2e = 0;
1545 BYTE V2e = 0;
1546 BYTE Y1o = 0;
1547 BYTE Y2o = 0;
1548 BYTE U1o = 0;
1549 BYTE V1o = 0;
1550 BYTE U2o = 0;
1551 BYTE V2o = 0;
1552 /* Read 4 pixels, 2 from even, 2 from odd lines */
1553 {
1554 const BYTE r = *srcEven++;
1555 const BYTE g = *srcEven++;
1556 const BYTE b = *srcEven++;
1557 srcEven++;
1558 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1559 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1560 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1561 }
1562
1563 if (!lastX)
1564 {
1565 const BYTE r = *srcEven++;
1566 const BYTE g = *srcEven++;
1567 const BYTE b = *srcEven++;
1568 srcEven++;
1569 Y2e = RGB2Y(r, g, b);
1570 U2e = RGB2U(r, g, b);
1571 V2e = RGB2V(r, g, b);
1572 }
1573
1574 if (b1Odd)
1575 {
1576 const BYTE r = *srcOdd++;
1577 const BYTE g = *srcOdd++;
1578 const BYTE b = *srcOdd++;
1579 srcOdd++;
1580 Y1o = Y2o = RGB2Y(r, g, b);
1581 U1o = U2o = RGB2U(r, g, b);
1582 V1o = V2o = RGB2V(r, g, b);
1583 }
1584
1585 if (b1Odd && !lastX)
1586 {
1587 const BYTE r = *srcOdd++;
1588 const BYTE g = *srcOdd++;
1589 const BYTE b = *srcOdd++;
1590 srcOdd++;
1591 Y2o = RGB2Y(r, g, b);
1592 U2o = RGB2U(r, g, b);
1593 V2o = RGB2V(r, g, b);
1594 }
1595
1596 /* We have 4 Y pixels, so store them. */
1597 *b1Even++ = Y1e;
1598 *b1Even++ = Y2e;
1599
1600 if (b1Odd)
1601 {
1602 *b1Odd++ = Y1o;
1603 *b1Odd++ = Y2o;
1604 }
1605
1606 /* 2x 2y pixel in luma UV plane use averaging
1607 */
1608 {
1609 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)U1e + U2e + U1o + U2o) / 4);
1610 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(BYTE, ((UINT16)V1e + V2e + V1o + V2o) / 4);
1611 *b2++ = Uavg;
1612 *b3++ = Vavg;
1613 }
1614
1615 /* UV from 2x, 2y+1 */
1616 if (b1Odd)
1617 {
1618 *b4++ = U1o;
1619 *b5++ = V1o;
1620
1621 if (!lastX)
1622 {
1623 *b4++ = U2o;
1624 *b5++ = V2o;
1625 }
1626 }
1627
1628 /* UV from 2x+1, 2y */
1629 if (!lastX)
1630 {
1631 *b6++ = U2e;
1632 *b7++ = V2e;
1633 }
1634 }
1635}
1636
1637static inline pstatus_t general_RGBToAVC444YUV_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,
1638 BYTE* WINPR_RESTRICT pDst1[3],
1639 const UINT32 dst1Step[3],
1640 BYTE* WINPR_RESTRICT pDst2[3],
1641 const UINT32 dst2Step[3],
1642 const prim_size_t* WINPR_RESTRICT roi)
1643{
1649 size_t y = 0;
1650 for (; y < roi->height - roi->height % 2; y += 2)
1651 {
1652 const BOOL last = (y >= (roi->height - 1));
1653 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1654 const BYTE* srcOdd = pSrc + 1ULL * (y + 1) * srcStep;
1655 const size_t i = y >> 1;
1656 const size_t n = (i & (size_t)~7) + i;
1657 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1658 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : nullptr;
1659 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1660 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1661 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1662 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1663 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1664 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1665 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, srcOdd, b1Even, b1Odd, b2, b3, b4, b5, b6,
1666 b7, roi->width);
1667 }
1668 for (; y < roi->height; y++)
1669 {
1670 const BYTE* srcEven = pSrc + 1ULL * y * srcStep;
1671 BYTE* b1Even = pDst1[0] + 1ULL * y * dst1Step[0];
1672 BYTE* b2 = pDst1[1] + 1ULL * (y / 2) * dst1Step[1];
1673 BYTE* b3 = pDst1[2] + 1ULL * (y / 2) * dst1Step[2];
1674 BYTE* b6 = pDst2[1] + 1ULL * (y / 2) * dst2Step[1];
1675 BYTE* b7 = pDst2[2] + 1ULL * (y / 2) * dst2Step[2];
1676 general_RGBToAVC444YUV_RGBX_DOUBLE_ROW(srcEven, nullptr, b1Even, nullptr, b2, b3, nullptr,
1677 nullptr, b6, b7, roi->width);
1678 }
1679 return PRIMITIVES_SUCCESS;
1680}
1681
1682static inline void general_RGBToAVC444YUV_ANY_DOUBLE_ROW(
1683 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1684 BYTE* WINPR_RESTRICT b1Even, BYTE* WINPR_RESTRICT b1Odd, BYTE* WINPR_RESTRICT b2,
1685 BYTE* WINPR_RESTRICT b3, BYTE* WINPR_RESTRICT b4, BYTE* WINPR_RESTRICT b5,
1686 BYTE* WINPR_RESTRICT b6, BYTE* WINPR_RESTRICT b7, UINT32 width)
1687{
1688 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1689 for (UINT32 x = 0; x < width; x += 2)
1690 {
1691 const BOOL lastX = (x + 1) >= width;
1692 BYTE Y1e = 0;
1693 BYTE Y2e = 0;
1694 BYTE U1e = 0;
1695 BYTE V1e = 0;
1696 BYTE U2e = 0;
1697 BYTE V2e = 0;
1698 BYTE Y1o = 0;
1699 BYTE Y2o = 0;
1700 BYTE U1o = 0;
1701 BYTE V1o = 0;
1702 BYTE U2o = 0;
1703 BYTE V2o = 0;
1704 /* Read 4 pixels, 2 from even, 2 from odd lines */
1705 {
1706 BYTE r = 0;
1707 BYTE g = 0;
1708 BYTE b = 0;
1709 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1710 srcEven += bpp;
1711 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1712 Y1e = Y2e = Y1o = Y2o = RGB2Y(r, g, b);
1713 U1e = U2e = U1o = U2o = RGB2U(r, g, b);
1714 V1e = V2e = V1o = V2o = RGB2V(r, g, b);
1715 }
1716
1717 if (!lastX)
1718 {
1719 BYTE r = 0;
1720 BYTE g = 0;
1721 BYTE b = 0;
1722 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1723 srcEven += bpp;
1724 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1725 Y2e = RGB2Y(r, g, b);
1726 U2e = RGB2U(r, g, b);
1727 V2e = RGB2V(r, g, b);
1728 }
1729
1730 if (b1Odd)
1731 {
1732 BYTE r = 0;
1733 BYTE g = 0;
1734 BYTE b = 0;
1735 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1736 srcOdd += bpp;
1737 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1738 Y1o = Y2o = RGB2Y(r, g, b);
1739 U1o = U2o = RGB2U(r, g, b);
1740 V1o = V2o = RGB2V(r, g, b);
1741 }
1742
1743 if (b1Odd && !lastX)
1744 {
1745 BYTE r = 0;
1746 BYTE g = 0;
1747 BYTE b = 0;
1748 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1749 srcOdd += bpp;
1750 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1751 Y2o = RGB2Y(r, g, b);
1752 U2o = RGB2U(r, g, b);
1753 V2o = RGB2V(r, g, b);
1754 }
1755
1756 /* We have 4 Y pixels, so store them. */
1757 *b1Even++ = Y1e;
1758 *b1Even++ = Y2e;
1759
1760 if (b1Odd)
1761 {
1762 *b1Odd++ = Y1o;
1763 *b1Odd++ = Y2o;
1764 }
1765
1766 /* 2x 2y pixel in luma UV plane use averaging
1767 */
1768 {
1769 const BYTE Uavg = WINPR_ASSERTING_INT_CAST(
1770 BYTE, ((UINT16)U1e + (UINT16)U2e + (UINT16)U1o + (UINT16)U2o) / 4);
1771 const BYTE Vavg = WINPR_ASSERTING_INT_CAST(
1772 BYTE, ((UINT16)V1e + (UINT16)V2e + (UINT16)V1o + (UINT16)V2o) / 4);
1773 *b2++ = Uavg;
1774 *b3++ = Vavg;
1775 }
1776
1777 /* UV from 2x, 2y+1 */
1778 if (b1Odd)
1779 {
1780 *b4++ = U1o;
1781 *b5++ = V1o;
1782
1783 if (!lastX)
1784 {
1785 *b4++ = U2o;
1786 *b5++ = V2o;
1787 }
1788 }
1789
1790 /* UV from 2x+1, 2y */
1791 if (!lastX)
1792 {
1793 *b6++ = U2e;
1794 *b7++ = V2e;
1795 }
1796 }
1797}
1798
1799static inline pstatus_t
1800general_RGBToAVC444YUV_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
1801 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
1802 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
1803 const prim_size_t* WINPR_RESTRICT roi)
1804{
1862 const BYTE* pMaxSrc = pSrc + 1ULL * (roi->height - 1) * srcStep;
1863
1864 for (size_t y = 0; y < roi->height; y += 2)
1865 {
1866 WINPR_ASSERT(y < UINT32_MAX);
1867
1868 const BOOL last = (y >= (roi->height - 1));
1869 const BYTE* srcEven = y < roi->height ? pSrc + y * srcStep : pMaxSrc;
1870 const BYTE* srcOdd = !last ? pSrc + (y + 1) * srcStep : pMaxSrc;
1871 const UINT32 i = (UINT32)y >> 1;
1872 const UINT32 n = (i & (uint32_t)~7) + i;
1873 BYTE* b1Even = pDst1[0] + y * dst1Step[0];
1874 BYTE* b1Odd = !last ? (b1Even + dst1Step[0]) : nullptr;
1875 BYTE* b2 = pDst1[1] + (y / 2) * dst1Step[1];
1876 BYTE* b3 = pDst1[2] + (y / 2) * dst1Step[2];
1877 BYTE* b4 = pDst2[0] + 1ULL * dst2Step[0] * n;
1878 BYTE* b5 = b4 + 8ULL * dst2Step[0];
1879 BYTE* b6 = pDst2[1] + (y / 2) * dst2Step[1];
1880 BYTE* b7 = pDst2[2] + (y / 2) * dst2Step[2];
1881 general_RGBToAVC444YUV_ANY_DOUBLE_ROW(srcEven, srcOdd, srcFormat, b1Even, b1Odd, b2, b3, b4,
1882 b5, b6, b7, roi->width);
1883 }
1884
1885 return PRIMITIVES_SUCCESS;
1886}
1887
1888static inline pstatus_t general_RGBToAVC444YUV(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
1889 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
1890 const UINT32 dst1Step[3],
1891 BYTE* WINPR_RESTRICT pDst2[3],
1892 const UINT32 dst2Step[3],
1893 const prim_size_t* WINPR_RESTRICT roi)
1894{
1895 if (!pSrc || !pDst1 || !dst1Step || !pDst2 || !dst2Step)
1896 return -1;
1897
1898 if (!pDst1[0] || !pDst1[1] || !pDst1[2])
1899 return -1;
1900
1901 if (!dst1Step[0] || !dst1Step[1] || !dst1Step[2])
1902 return -1;
1903
1904 if (!pDst2[0] || !pDst2[1] || !pDst2[2])
1905 return -1;
1906
1907 if (!dst2Step[0] || !dst2Step[1] || !dst2Step[2])
1908 return -1;
1909
1910 switch (srcFormat)
1911 {
1912
1913 case PIXEL_FORMAT_BGRA32:
1914 case PIXEL_FORMAT_BGRX32:
1915 return general_RGBToAVC444YUV_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1916 roi);
1917
1918 case PIXEL_FORMAT_RGBA32:
1919 case PIXEL_FORMAT_RGBX32:
1920 return general_RGBToAVC444YUV_RGBX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
1921 roi);
1922
1923 default:
1924 return general_RGBToAVC444YUV_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
1925 dst2Step, roi);
1926 }
1927
1928 return !PRIMITIVES_SUCCESS;
1929}
1930
1931static inline void general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
1932 const BYTE* WINPR_RESTRICT srcEven, const BYTE* WINPR_RESTRICT srcOdd, UINT32 srcFormat,
1933 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
1934 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
1935 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
1936 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
1937 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
1938 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
1939{
1940 const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);
1941
1942 for (UINT32 x = 0; x < width; x += 2)
1943 {
1944 BYTE Ya = 0;
1945 BYTE Ua = 0;
1946 BYTE Va = 0;
1947 BYTE Yb = 0;
1948 BYTE Ub = 0;
1949 BYTE Vb = 0;
1950 BYTE Yc = 0;
1951 BYTE Uc = 0;
1952 BYTE Vc = 0;
1953 BYTE Yd = 0;
1954 BYTE Ud = 0;
1955 BYTE Vd = 0;
1956 {
1957 BYTE b = 0;
1958 BYTE g = 0;
1959 BYTE r = 0;
1960 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1961 srcEven += bpp;
1962 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1963 Ya = RGB2Y(r, g, b);
1964 Ua = RGB2U(r, g, b);
1965 Va = RGB2V(r, g, b);
1966 }
1967
1968 if (x < width - 1)
1969 {
1970 BYTE b = 0;
1971 BYTE g = 0;
1972 BYTE r = 0;
1973 const UINT32 color = FreeRDPReadColor(srcEven, srcFormat);
1974 srcEven += bpp;
1975 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1976 Yb = RGB2Y(r, g, b);
1977 Ub = RGB2U(r, g, b);
1978 Vb = RGB2V(r, g, b);
1979 }
1980 else
1981 {
1982 Yb = Ya;
1983 Ub = Ua;
1984 Vb = Va;
1985 }
1986
1987 if (srcOdd)
1988 {
1989 BYTE b = 0;
1990 BYTE g = 0;
1991 BYTE r = 0;
1992 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
1993 srcOdd += bpp;
1994 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
1995 Yc = RGB2Y(r, g, b);
1996 Uc = RGB2U(r, g, b);
1997 Vc = RGB2V(r, g, b);
1998 }
1999 else
2000 {
2001 Yc = Ya;
2002 Uc = Ua;
2003 Vc = Va;
2004 }
2005
2006 if (srcOdd && (x < width - 1))
2007 {
2008 BYTE b = 0;
2009 BYTE g = 0;
2010 BYTE r = 0;
2011 const UINT32 color = FreeRDPReadColor(srcOdd, srcFormat);
2012 srcOdd += bpp;
2013 FreeRDPSplitColor(color, srcFormat, &r, &g, &b, nullptr, nullptr);
2014 Yd = RGB2Y(r, g, b);
2015 Ud = RGB2U(r, g, b);
2016 Vd = RGB2V(r, g, b);
2017 }
2018 else
2019 {
2020 Yd = Ya;
2021 Ud = Ua;
2022 Vd = Va;
2023 }
2024
2025 /* Y [b1] */
2026 *yLumaDstEven++ = Ya;
2027
2028 if (x < width - 1)
2029 *yLumaDstEven++ = Yb;
2030
2031 if (srcOdd)
2032 *yLumaDstOdd++ = Yc;
2033
2034 if (srcOdd && (x < width - 1))
2035 *yLumaDstOdd++ = Yd;
2036
2037 /* 2x 2y [b2,b3] */
2038 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2039 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2040
2041 /* 2x+1, y [b4,b5] even */
2042 if (x < width - 1)
2043 {
2044 *yEvenChromaDst1++ = Ub;
2045 *yEvenChromaDst2++ = Vb;
2046 }
2047
2048 if (srcOdd)
2049 {
2050 /* 2x+1, y [b4,b5] odd */
2051 if (x < width - 1)
2052 {
2053 *yOddChromaDst1++ = Ud;
2054 *yOddChromaDst2++ = Vd;
2055 }
2056
2057 /* 4x 2y+1 [b6, b7] */
2058 if (x % 4 == 0)
2059 {
2060 *uChromaDst1++ = Uc;
2061 *uChromaDst2++ = Vc;
2062 }
2063 /* 4x+2 2y+1 [b8, b9] */
2064 else
2065 {
2066 *vChromaDst1++ = Uc;
2067 *vChromaDst2++ = Vc;
2068 }
2069 }
2070 }
2071}
2072
2073static inline pstatus_t
2074general_RGBToAVC444YUVv2_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat, UINT32 srcStep,
2075 BYTE* WINPR_RESTRICT pDst1[3], const UINT32 dst1Step[3],
2076 BYTE* WINPR_RESTRICT pDst2[3], const UINT32 dst2Step[3],
2077 const prim_size_t* WINPR_RESTRICT roi)
2078{
2129 if (roi->height < 1 || roi->width < 1)
2130 return !PRIMITIVES_SUCCESS;
2131
2132 size_t y = 0;
2133 for (; y < roi->height - roi->height % 2; y += 2)
2134 {
2135 const BYTE* srcEven = (pSrc + y * srcStep);
2136 const BYTE* srcOdd = (y < roi->height - 1) ? (srcEven + srcStep) : nullptr;
2137 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2138 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2139 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2140 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2141 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2142 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2143 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2144 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2145 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2146 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2147 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2148 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2149 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2150 srcEven, srcOdd, srcFormat, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV,
2151 dstEvenChromaY1, dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1,
2152 dstChromaU2, dstChromaV1, dstChromaV2, roi->width);
2153 }
2154 for (; y < roi->height; y++)
2155 {
2156 const BYTE* srcEven = (pSrc + y * srcStep);
2157 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2158 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2159 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2160 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2161 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2162 general_RGBToAVC444YUVv2_ANY_DOUBLE_ROW(
2163 srcEven, nullptr, srcFormat, dstLumaYEven, nullptr, dstLumaU, dstLumaV, dstEvenChromaY1,
2164 dstEvenChromaY2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, roi->width);
2165 }
2166
2167 return PRIMITIVES_SUCCESS;
2168}
2169
2170static inline void int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2171 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2172 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2173 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2174 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2175 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2176 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2177 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2178{
2179 WINPR_ASSERT(pSrcEven);
2180 WINPR_ASSERT(yLumaDstEven);
2181 WINPR_ASSERT(uLumaDst);
2182 WINPR_ASSERT(vLumaDst);
2183
2184 for (size_t x = offset; x < width; x += 2)
2185 {
2186 const BYTE* srcEven = &pSrcEven[4ULL * x];
2187 const BYTE* srcOdd = pSrcOdd ? &pSrcOdd[4ULL * x] : nullptr;
2188 BYTE Ya = 0;
2189 BYTE Ua = 0;
2190 BYTE Va = 0;
2191 BYTE Yb = 0;
2192 BYTE Ub = 0;
2193 BYTE Vb = 0;
2194 BYTE Yc = 0;
2195 BYTE Uc = 0;
2196 BYTE Vc = 0;
2197 BYTE Yd = 0;
2198 BYTE Ud = 0;
2199 BYTE Vd = 0;
2200 {
2201 const BYTE b = *srcEven++;
2202 const BYTE g = *srcEven++;
2203 const BYTE r = *srcEven++;
2204 srcEven++;
2205 Ya = RGB2Y(r, g, b);
2206 Ua = RGB2U(r, g, b);
2207 Va = RGB2V(r, g, b);
2208 }
2209
2210 if (x < width - 1)
2211 {
2212 const BYTE b = *srcEven++;
2213 const BYTE g = *srcEven++;
2214 const BYTE r = *srcEven++;
2215 srcEven++;
2216 Yb = RGB2Y(r, g, b);
2217 Ub = RGB2U(r, g, b);
2218 Vb = RGB2V(r, g, b);
2219 }
2220 else
2221 {
2222 Yb = Ya;
2223 Ub = Ua;
2224 Vb = Va;
2225 }
2226
2227 if (srcOdd)
2228 {
2229 const BYTE b = *srcOdd++;
2230 const BYTE g = *srcOdd++;
2231 const BYTE r = *srcOdd++;
2232 srcOdd++;
2233 Yc = RGB2Y(r, g, b);
2234 Uc = RGB2U(r, g, b);
2235 Vc = RGB2V(r, g, b);
2236 }
2237 else
2238 {
2239 Yc = Ya;
2240 Uc = Ua;
2241 Vc = Va;
2242 }
2243
2244 if (srcOdd && (x < width - 1))
2245 {
2246 const BYTE b = *srcOdd++;
2247 const BYTE g = *srcOdd++;
2248 const BYTE r = *srcOdd++;
2249 srcOdd++;
2250 Yd = RGB2Y(r, g, b);
2251 Ud = RGB2U(r, g, b);
2252 Vd = RGB2V(r, g, b);
2253 }
2254 else
2255 {
2256 Yd = Ya;
2257 Ud = Ua;
2258 Vd = Va;
2259 }
2260
2261 /* Y [b1] */
2262 *yLumaDstEven++ = Ya;
2263
2264 if (x < width - 1)
2265 *yLumaDstEven++ = Yb;
2266
2267 if (srcOdd && yLumaDstOdd)
2268 *yLumaDstOdd++ = Yc;
2269
2270 if (srcOdd && (x < width - 1) && yLumaDstOdd)
2271 *yLumaDstOdd++ = Yd;
2272
2273 /* 2x 2y [b2,b3] */
2274 *uLumaDst++ = (Ua + Ub + Uc + Ud) / 4;
2275 *vLumaDst++ = (Va + Vb + Vc + Vd) / 4;
2276
2277 /* 2x+1, y [b4,b5] even */
2278 if (x < width - 1)
2279 {
2280 *yEvenChromaDst1++ = Ub;
2281 *yEvenChromaDst2++ = Vb;
2282 }
2283
2284 if (srcOdd)
2285 {
2286 /* 2x+1, y [b4,b5] odd */
2287 if (x < width - 1)
2288 {
2289 *yOddChromaDst1++ = Ud;
2290 *yOddChromaDst2++ = Vd;
2291 }
2292
2293 /* 4x 2y+1 [b6, b7] */
2294 if (x % 4 == 0)
2295 {
2296 *uChromaDst1++ = Uc;
2297 *uChromaDst2++ = Vc;
2298 }
2299 /* 4x+2 2y+1 [b8, b9] */
2300 else
2301 {
2302 *vChromaDst1++ = Uc;
2303 *vChromaDst2++ = Vc;
2304 }
2305 }
2306 }
2307}
2308
2309void general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2310 size_t offset, const BYTE* WINPR_RESTRICT pSrcEven, const BYTE* WINPR_RESTRICT pSrcOdd,
2311 BYTE* WINPR_RESTRICT yLumaDstEven, BYTE* WINPR_RESTRICT yLumaDstOdd,
2312 BYTE* WINPR_RESTRICT uLumaDst, BYTE* WINPR_RESTRICT vLumaDst,
2313 BYTE* WINPR_RESTRICT yEvenChromaDst1, BYTE* WINPR_RESTRICT yEvenChromaDst2,
2314 BYTE* WINPR_RESTRICT yOddChromaDst1, BYTE* WINPR_RESTRICT yOddChromaDst2,
2315 BYTE* WINPR_RESTRICT uChromaDst1, BYTE* WINPR_RESTRICT uChromaDst2,
2316 BYTE* WINPR_RESTRICT vChromaDst1, BYTE* WINPR_RESTRICT vChromaDst2, UINT32 width)
2317{
2318 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2319 offset, pSrcEven, pSrcOdd, yLumaDstEven, yLumaDstOdd, uLumaDst, vLumaDst, yEvenChromaDst1,
2320 yEvenChromaDst2, yOddChromaDst1, yOddChromaDst2, uChromaDst1, uChromaDst2, vChromaDst1,
2321 vChromaDst2, width);
2322}
2323
2324static inline pstatus_t general_RGBToAVC444YUVv2_BGRX(const BYTE* WINPR_RESTRICT pSrc,
2325 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2326 const UINT32 dst1Step[3],
2327 BYTE* WINPR_RESTRICT pDst2[3],
2328 const UINT32 dst2Step[3],
2329 const prim_size_t* WINPR_RESTRICT roi)
2330{
2331 if (roi->height < 1 || roi->width < 1)
2332 return !PRIMITIVES_SUCCESS;
2333
2334 size_t y = 0;
2335 for (; y < roi->height - roi->height % 2; y += 2)
2336 {
2337 const BYTE* srcEven = (pSrc + y * srcStep);
2338 const BYTE* srcOdd = (srcEven + srcStep);
2339 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2340 BYTE* dstLumaYOdd = (dstLumaYEven + dst1Step[0]);
2341 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2342 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2343 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2344 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2345 BYTE* dstOddChromaY1 = dstEvenChromaY1 + dst2Step[0];
2346 BYTE* dstOddChromaY2 = dstEvenChromaY2 + dst2Step[0];
2347 BYTE* dstChromaU1 = (pDst2[1] + (y / 2) * dst2Step[1]);
2348 BYTE* dstChromaV1 = (pDst2[2] + (y / 2) * dst2Step[2]);
2349 BYTE* dstChromaU2 = dstChromaU1 + roi->width / 4;
2350 BYTE* dstChromaV2 = dstChromaV1 + roi->width / 4;
2351 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2352 0, srcEven, srcOdd, dstLumaYEven, dstLumaYOdd, dstLumaU, dstLumaV, dstEvenChromaY1,
2353 dstEvenChromaY2, dstOddChromaY1, dstOddChromaY2, dstChromaU1, dstChromaU2, dstChromaV1,
2354 dstChromaV2, roi->width);
2355 }
2356 for (; y < roi->height; y++)
2357 {
2358 const BYTE* srcEven = (pSrc + y * srcStep);
2359 BYTE* dstLumaYEven = (pDst1[0] + y * dst1Step[0]);
2360 BYTE* dstLumaU = (pDst1[1] + (y / 2) * dst1Step[1]);
2361 BYTE* dstLumaV = (pDst1[2] + (y / 2) * dst1Step[2]);
2362 BYTE* dstEvenChromaY1 = (pDst2[0] + y * dst2Step[0]);
2363 BYTE* dstEvenChromaY2 = dstEvenChromaY1 + roi->width / 2;
2364 int_general_RGBToAVC444YUVv2_BGRX_DOUBLE_ROW(
2365 0, srcEven, nullptr, dstLumaYEven, nullptr, dstLumaU, dstLumaV, dstEvenChromaY1,
2366 dstEvenChromaY2, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, roi->width);
2367 }
2368
2369 return PRIMITIVES_SUCCESS;
2370}
2371
2372static pstatus_t general_RGBToAVC444YUVv2(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,
2373 UINT32 srcStep, BYTE* WINPR_RESTRICT pDst1[3],
2374 const UINT32 dst1Step[3], BYTE* WINPR_RESTRICT pDst2[3],
2375 const UINT32 dst2Step[3],
2376 const prim_size_t* WINPR_RESTRICT roi)
2377{
2378 switch (srcFormat)
2379 {
2380 case PIXEL_FORMAT_BGRA32:
2381 case PIXEL_FORMAT_BGRX32:
2382 return general_RGBToAVC444YUVv2_BGRX(pSrc, srcStep, pDst1, dst1Step, pDst2, dst2Step,
2383 roi);
2384
2385 default:
2386 return general_RGBToAVC444YUVv2_ANY(pSrc, srcFormat, srcStep, pDst1, dst1Step, pDst2,
2387 dst2Step, roi);
2388 }
2389
2390 return !PRIMITIVES_SUCCESS;
2391}
2392
2393void primitives_init_YUV(primitives_t* WINPR_RESTRICT prims)
2394{
2395 prims->YUV420ToRGB_8u_P3AC4R = general_YUV420ToRGB_8u_P3AC4R;
2396 prims->YUV444ToRGB_8u_P3AC4R = general_YUV444ToRGB_8u_P3AC4R;
2397 prims->RGBToYUV420_8u_P3AC4R = general_RGBToYUV420_8u_P3AC4R;
2398 prims->RGBToYUV444_8u_P3AC4R = general_RGBToYUV444_8u_P3AC4R;
2399 prims->RGBToI444_8u = general_RGBToI444_8u;
2400 prims->I444ToRGB_8u = general_I444ToRGB_8u;
2401 prims->YUV420CombineToYUV444 = general_YUV420CombineToYUV444;
2402 prims->YUV444SplitToYUV420 = general_YUV444SplitToYUV420;
2403 prims->RGBToAVC444YUV = general_RGBToAVC444YUV;
2404 prims->RGBToAVC444YUVv2 = general_RGBToAVC444YUVv2;
2405}
2406
2407void primitives_init_YUV_opt(primitives_t* WINPR_RESTRICT prims)
2408{
2409 primitives_init_YUV(prims);
2410 primitives_init_YUV_sse41(prims);
2411 primitives_init_YUV_neon(prims);
2412}
RECTANGLE_16
Definition types.h:109
prim_size_t
Definition primitives.h:74
primitives_t
Definition primitives.h:255