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