FreeRDP
Loading...
Searching...
No Matches
rfx_encode.c
1
21#include <freerdp/config.h>
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include <winpr/crt.h>
28#include <winpr/collections.h>
29
30#include <freerdp/primitives.h>
31
32#include "rfx_types.h"
33#include "rfx_rlgr.h"
34#include "rfx_differential.h"
35#include "rfx_quantization.h"
36#include "rfx_dwt.h"
37
38#include "rfx_encode.h"
39
40static void rfx_encode_format_rgb(const BYTE* WINPR_RESTRICT rgb_data, uint32_t width,
41 uint32_t height, uint32_t rowstride, UINT32 pixel_format,
42 const BYTE* WINPR_RESTRICT palette, INT16* WINPR_RESTRICT r_buf,
43 INT16* WINPR_RESTRICT g_buf, INT16* WINPR_RESTRICT b_buf)
44{
45 const BYTE* src = nullptr;
46 INT16 r = 0;
47 INT16 g = 0;
48 INT16 b = 0;
49 INT16* r_last = nullptr;
50 INT16* g_last = nullptr;
51 INT16* b_last = nullptr;
52 uint32_t x_exceed = 64 - width;
53 uint32_t y_exceed = 64 - height;
54
55 for (uint32_t y = 0; y < height; y++)
56 {
57 src = rgb_data + 1ULL * y * rowstride;
58
59 switch (pixel_format)
60 {
61 case PIXEL_FORMAT_BGRX32:
62 case PIXEL_FORMAT_BGRA32:
63 for (uint32_t x = 0; x < width; x++)
64 {
65 *b_buf++ = (INT16)(*src++);
66 *g_buf++ = (INT16)(*src++);
67 *r_buf++ = (INT16)(*src++);
68 src++;
69 }
70
71 break;
72
73 case PIXEL_FORMAT_XBGR32:
74 case PIXEL_FORMAT_ABGR32:
75 for (size_t x = 0; x < width; x++)
76 {
77 src++;
78 *b_buf++ = (INT16)(*src++);
79 *g_buf++ = (INT16)(*src++);
80 *r_buf++ = (INT16)(*src++);
81 }
82
83 break;
84
85 case PIXEL_FORMAT_RGBX32:
86 case PIXEL_FORMAT_RGBA32:
87 for (size_t x = 0; x < width; x++)
88 {
89 *r_buf++ = (INT16)(*src++);
90 *g_buf++ = (INT16)(*src++);
91 *b_buf++ = (INT16)(*src++);
92 src++;
93 }
94
95 break;
96
97 case PIXEL_FORMAT_XRGB32:
98 case PIXEL_FORMAT_ARGB32:
99 for (size_t x = 0; x < width; x++)
100 {
101 src++;
102 *r_buf++ = (INT16)(*src++);
103 *g_buf++ = (INT16)(*src++);
104 *b_buf++ = (INT16)(*src++);
105 }
106
107 break;
108
109 case PIXEL_FORMAT_BGR24:
110 for (size_t x = 0; x < width; x++)
111 {
112 *b_buf++ = (INT16)(*src++);
113 *g_buf++ = (INT16)(*src++);
114 *r_buf++ = (INT16)(*src++);
115 }
116
117 break;
118
119 case PIXEL_FORMAT_RGB24:
120 for (size_t x = 0; x < width; x++)
121 {
122 *r_buf++ = (INT16)(*src++);
123 *g_buf++ = (INT16)(*src++);
124 *b_buf++ = (INT16)(*src++);
125 }
126
127 break;
128
129 case PIXEL_FORMAT_BGR16:
130 for (size_t x = 0; x < width; x++)
131 {
132 *b_buf++ = (INT16)(((*(src + 1)) & 0xF8) | ((*(src + 1)) >> 5));
133 *g_buf++ = (INT16)((((*(src + 1)) & 0x07) << 5) | (((*src) & 0xE0) >> 3));
134 *r_buf++ = (INT16)((((*src) & 0x1F) << 3) | (((*src) >> 2) & 0x07));
135 src += 2;
136 }
137
138 break;
139
140 case PIXEL_FORMAT_RGB16:
141 for (size_t x = 0; x < width; x++)
142 {
143 *r_buf++ = (INT16)(((*(src + 1)) & 0xF8) | ((*(src + 1)) >> 5));
144 *g_buf++ = (INT16)((((*(src + 1)) & 0x07) << 5) | (((*src) & 0xE0) >> 3));
145 *b_buf++ = (INT16)((((*src) & 0x1F) << 3) | (((*src) >> 2) & 0x07));
146 src += 2;
147 }
148
149 break;
150
151 case PIXEL_FORMAT_RGB8:
152 if (!palette)
153 break;
154
155 for (size_t x = 0; x < width; x++)
156 {
157 BYTE idx = 0;
158 const size_t shift = (7 - (x % 8));
159 idx = ((*src) >> shift) & 1;
160 idx |= (((*(src + 1)) >> shift) & 1) << 1;
161 idx |= (((*(src + 2)) >> shift) & 1) << 2;
162 idx |= (((*(src + 3)) >> shift) & 1) << 3;
163 idx *= 3;
164 *r_buf++ = (INT16)palette[idx];
165 *g_buf++ = (INT16)palette[idx + 1];
166 *b_buf++ = (INT16)palette[idx + 2];
167
168 if (shift == 0)
169 src += 4;
170 }
171
172 break;
173
174 case PIXEL_FORMAT_A4:
175 if (!palette)
176 break;
177
178 for (size_t x = 0; x < width; x++)
179 {
180 int idx = (*src) * 3;
181 *r_buf++ = (INT16)palette[idx];
182 *g_buf++ = (INT16)palette[idx + 1];
183 *b_buf++ = (INT16)palette[idx + 2];
184 src++;
185 }
186
187 break;
188
189 default:
190 break;
191 }
192
193 /* Fill the horizontal region outside of 64x64 tile size with the right-most pixel for best
194 * quality */
195 if (x_exceed > 0)
196 {
197 r = *(r_buf - 1);
198 g = *(g_buf - 1);
199 b = *(b_buf - 1);
200
201 for (size_t x = 0; x < x_exceed; x++)
202 {
203 *r_buf++ = r;
204 *g_buf++ = g;
205 *b_buf++ = b;
206 }
207 }
208 }
209
210 /* Fill the vertical region outside of 64x64 tile size with the last line. */
211 if (y_exceed > 0)
212 {
213 r_last = r_buf - 64;
214 g_last = g_buf - 64;
215 b_last = b_buf - 64;
216
217 while (y_exceed > 0)
218 {
219 CopyMemory(r_buf, r_last, 64 * sizeof(INT16));
220 CopyMemory(g_buf, g_last, 64 * sizeof(INT16));
221 CopyMemory(b_buf, b_last, 64 * sizeof(INT16));
222 r_buf += 64;
223 g_buf += 64;
224 b_buf += 64;
225 y_exceed--;
226 }
227 }
228}
229
230/* rfx_encode_rgb_to_ycbcr code now resides in the primitives library. */
231WINPR_ATTR_NODISCARD
232static BOOL rfx_encode_component(RFX_CONTEXT* WINPR_RESTRICT context,
233 const UINT32* WINPR_RESTRICT quantization_values,
234 size_t nrQuantValues, INT16* WINPR_RESTRICT data,
235 BYTE* WINPR_RESTRICT buffer, uint32_t buffer_size,
236 uint32_t* WINPR_RESTRICT size)
237{
238 BOOL res = FALSE;
239 int rc = -1;
240 INT16* dwt_buffer = BufferPool_Take(context->priv->BufferPool, -1); /* dwt_buffer */
241 if (!dwt_buffer)
242 return FALSE;
243
244 PROFILER_ENTER(context->priv->prof_rfx_encode_component)
245 PROFILER_ENTER(context->priv->prof_rfx_dwt_2d_encode)
246 context->dwt_2d_encode(data, dwt_buffer);
247 PROFILER_EXIT(context->priv->prof_rfx_dwt_2d_encode)
248 PROFILER_ENTER(context->priv->prof_rfx_quantization_encode)
249 if (!context->quantization_encode(data, quantization_values, nrQuantValues))
250 goto fail;
251 PROFILER_EXIT(context->priv->prof_rfx_quantization_encode)
252 PROFILER_ENTER(context->priv->prof_rfx_differential_encode)
253 rfx_differential_encode(data + 4032, 64);
254 PROFILER_EXIT(context->priv->prof_rfx_differential_encode)
255 PROFILER_ENTER(context->priv->prof_rfx_rlgr_encode)
256 rc = context->rlgr_encode(context->mode, data, 4096, buffer, buffer_size);
257 if (rc < 0)
258 goto fail;
259
260 PROFILER_EXIT(context->priv->prof_rfx_rlgr_encode)
261 PROFILER_EXIT(context->priv->prof_rfx_encode_component)
262
263 res = TRUE;
264
265fail:
266 BufferPool_Return(context->priv->BufferPool, dwt_buffer);
267
268 *size = WINPR_ASSERTING_INT_CAST(uint32_t, rc);
269 return res;
270}
271
272BOOL rfx_encode_rgb(RFX_CONTEXT* WINPR_RESTRICT context, RFX_TILE* WINPR_RESTRICT tile)
273{
274 BOOL rc = FALSE;
275 union
276 {
277 const INT16** cpv;
278 INT16** pv;
279 } cnv;
280 INT16* pSrcDst[3] = WINPR_C_ARRAY_INIT;
281 uint32_t CbLen = 0;
282 uint32_t CrLen = 0;
283 primitives_t* prims = primitives_get();
284 static const prim_size_t roi_64x64 = { 64, 64 };
285
286 BYTE* pBuffer = (BYTE*)BufferPool_Take(context->priv->BufferPool, -1);
287 if (!pBuffer)
288 return FALSE;
289
290 uint32_t YLen = CbLen = CrLen = 0;
291 UINT32* YQuant = context->quants + (NR_QUANT_VALUES * tile->quantIdxY);
292 UINT32* CbQuant = context->quants + (NR_QUANT_VALUES * tile->quantIdxCb);
293 UINT32* CrQuant = context->quants + (NR_QUANT_VALUES * tile->quantIdxCr);
294 pSrcDst[0] = (INT16*)((&pBuffer[((8192ULL + 32ULL) * 0ULL) + 16ULL])); /* y_r_buffer */
295 pSrcDst[1] = (INT16*)((&pBuffer[((8192ULL + 32ULL) * 1ULL) + 16ULL])); /* cb_g_buffer */
296 pSrcDst[2] = (INT16*)((&pBuffer[((8192ULL + 32ULL) * 2ULL) + 16ULL])); /* cr_b_buffer */
297 PROFILER_ENTER(context->priv->prof_rfx_encode_rgb)
298 PROFILER_ENTER(context->priv->prof_rfx_encode_format_rgb)
299 rfx_encode_format_rgb(tile->data, tile->width, tile->height, tile->scanline,
300 context->pixel_format, context->palette, pSrcDst[0], pSrcDst[1],
301 pSrcDst[2]);
302 PROFILER_EXIT(context->priv->prof_rfx_encode_format_rgb)
303 PROFILER_ENTER(context->priv->prof_rfx_rgb_to_ycbcr)
304
305 cnv.pv = pSrcDst;
306 if (prims->RGBToYCbCr_16s16s_P3P3(cnv.cpv, 64 * sizeof(INT16), pSrcDst, 64 * sizeof(INT16),
307 &roi_64x64) != PRIMITIVES_SUCCESS)
308 goto fail;
309
310 PROFILER_EXIT(context->priv->prof_rfx_rgb_to_ycbcr)
315 ZeroMemory(tile->YData, 4096);
316 ZeroMemory(tile->CbData, 4096);
317 ZeroMemory(tile->CrData, 4096);
318 if (!rfx_encode_component(context, YQuant, NR_QUANT_VALUES, pSrcDst[0], tile->YData, 4096,
319 &YLen))
320 goto fail;
321 if (!rfx_encode_component(context, CbQuant, NR_QUANT_VALUES, pSrcDst[1], tile->CbData, 4096,
322 &CbLen))
323 goto fail;
324 if (!rfx_encode_component(context, CrQuant, NR_QUANT_VALUES, pSrcDst[2], tile->CrData, 4096,
325 &CrLen))
326 goto fail;
327 tile->YLen = WINPR_ASSERTING_INT_CAST(UINT16, YLen);
328 tile->CbLen = WINPR_ASSERTING_INT_CAST(UINT16, CbLen);
329 tile->CrLen = WINPR_ASSERTING_INT_CAST(UINT16, CrLen);
330
331 rc = TRUE;
332
333fail:
334 PROFILER_EXIT(context->priv->prof_rfx_encode_rgb)
335 if (!BufferPool_Return(context->priv->BufferPool, pBuffer))
336 return FALSE;
337 return rc;
338}
RFX_TILE
Definition rfx.h:52
prim_size_t
Definition primitives.h:74
primitives_t
Definition primitives.h:255