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