FreeRDP
TestFreeRDPCodecZGfx.c
1 #include <winpr/crt.h>
2 #include <winpr/print.h>
3 #include <winpr/bitstream.h>
4 
5 #include <freerdp/freerdp.h>
6 #include <freerdp/codec/zgfx.h>
7 #include <freerdp/log.h>
8 
9 /* Sample from [MS-RDPEGFX] */
10 static const BYTE TEST_FOX_DATA[] = "The quick brown "
11  "fox jumps over t"
12  "he lazy dog";
13 
14 static const BYTE TEST_FOX_DATA_SINGLE[] =
15  "\xE0\x04\x54\x68\x65\x20\x71\x75\x69\x63\x6B\x20\x62\x72\x6F\x77"
16  "\x6E\x20\x66\x6F\x78\x20\x6A\x75\x6D\x70\x73\x20\x6F\x76\x65\x72"
17  "\x20\x74\x68\x65\x20\x6C\x61\x7A\x79\x20\x64\x6F\x67";
18 
19 static const BYTE TEST_FOX_DATA_MULTIPART[] =
20  "\xE1\x03\x00\x2B\x00\x00\x00\x11\x00\x00\x00\x04\x54\x68\x65\x20"
21  "\x71\x75\x69\x63\x6B\x20\x62\x72\x6F\x77\x6E\x20\x0E\x00\x00\x00"
22  "\x04\x66\x6F\x78\x20\x6A\x75\x6D\x70\x73\x20\x6F\x76\x65\x10\x00"
23  "\x00\x00\x24\x39\x08\x0E\x91\xF8\xD8\x61\x3D\x1E\x44\x06\x43\x79"
24  "\x9C\x02";
25 
26 static int test_ZGfxCompressFox(void)
27 {
28  int rc = -1;
29  int status = 0;
30  UINT32 Flags = 0;
31  const BYTE* pSrcData = NULL;
32  UINT32 SrcSize = 0;
33  UINT32 DstSize = 0;
34  BYTE* pDstData = NULL;
35  ZGFX_CONTEXT* zgfx = NULL;
36  UINT32 expectedSize = 0;
37  zgfx = zgfx_context_new(TRUE);
38 
39  if (!zgfx)
40  return -1;
41 
42  SrcSize = sizeof(TEST_FOX_DATA) - 1;
43  pSrcData = (const BYTE*)TEST_FOX_DATA;
44  Flags = 0;
45  expectedSize = sizeof(TEST_FOX_DATA_SINGLE) - 1;
46  status = zgfx_compress(zgfx, pSrcData, SrcSize, &pDstData, &DstSize, &Flags);
47 
48  if (status < 0)
49  goto fail;
50 
51  printf("flags: 0x%08" PRIX32 " size: %" PRIu32 "\n", Flags, DstSize);
52 
53  if (DstSize != expectedSize)
54  {
55  printf("test_ZGfxCompressFox: output size mismatch: Actual: %" PRIu32 ", Expected: %" PRIu32
56  "\n",
57  DstSize, expectedSize);
58  goto fail;
59  }
60 
61  if (memcmp(pDstData, TEST_FOX_DATA_SINGLE, DstSize) != 0)
62  {
63  printf("test_ZGfxCompressFox: output mismatch\n");
64  printf("Actual\n");
65  BitDump(__func__, WLOG_INFO, pDstData, DstSize * 8, 0);
66  printf("Expected\n");
67  BitDump(__func__, WLOG_INFO, TEST_FOX_DATA_SINGLE, DstSize * 8, 0);
68  goto fail;
69  }
70 
71  rc = 0;
72 fail:
73  free(pDstData);
74  zgfx_context_free(zgfx);
75  return rc;
76 }
77 
78 static int test_ZGfxDecompressFoxSingle(void)
79 {
80  int rc = -1;
81  int status = 0;
82  UINT32 Flags = 0;
83  const BYTE* pSrcData = NULL;
84  UINT32 SrcSize = 0;
85  UINT32 DstSize = 0;
86  BYTE* pDstData = NULL;
87  ZGFX_CONTEXT* zgfx = NULL;
88  UINT32 expectedSize = 0;
89  zgfx = zgfx_context_new(TRUE);
90 
91  if (!zgfx)
92  return -1;
93 
94  SrcSize = sizeof(TEST_FOX_DATA_SINGLE) - 1;
95  pSrcData = (const BYTE*)TEST_FOX_DATA_SINGLE;
96  Flags = 0;
97  expectedSize = sizeof(TEST_FOX_DATA) - 1;
98  status = zgfx_decompress(zgfx, pSrcData, SrcSize, &pDstData, &DstSize, Flags);
99 
100  if (status < 0)
101  goto fail;
102 
103  printf("flags: 0x%08" PRIX32 " size: %" PRIu32 "\n", Flags, DstSize);
104 
105  if (DstSize != expectedSize)
106  {
107  printf("test_ZGfxDecompressFoxSingle: output size mismatch: Actual: %" PRIu32
108  ", Expected: %" PRIu32 "\n",
109  DstSize, expectedSize);
110  goto fail;
111  }
112 
113  if (memcmp(pDstData, TEST_FOX_DATA, DstSize) != 0)
114  {
115  printf("test_ZGfxDecompressFoxSingle: output mismatch\n");
116  printf("Actual\n");
117  BitDump(__func__, WLOG_INFO, pDstData, DstSize * 8, 0);
118  printf("Expected\n");
119  BitDump(__func__, WLOG_INFO, TEST_FOX_DATA, DstSize * 8, 0);
120  goto fail;
121  }
122 
123  rc = 0;
124 fail:
125  free(pDstData);
126  zgfx_context_free(zgfx);
127  return rc;
128 }
129 
130 static int test_ZGfxDecompressFoxMultipart(void)
131 {
132  int rc = -1;
133  int status = 0;
134  UINT32 Flags = 0;
135  const BYTE* pSrcData = NULL;
136  UINT32 SrcSize = 0;
137  UINT32 DstSize = 0;
138  BYTE* pDstData = NULL;
139  ZGFX_CONTEXT* zgfx = NULL;
140  UINT32 expectedSize = 0;
141  zgfx = zgfx_context_new(TRUE);
142 
143  if (!zgfx)
144  return -1;
145 
146  SrcSize = sizeof(TEST_FOX_DATA_MULTIPART) - 1;
147  pSrcData = (const BYTE*)TEST_FOX_DATA_MULTIPART;
148  Flags = 0;
149  expectedSize = sizeof(TEST_FOX_DATA) - 1;
150  status = zgfx_decompress(zgfx, pSrcData, SrcSize, &pDstData, &DstSize, Flags);
151 
152  if (status < 0)
153  goto fail;
154 
155  printf("flags: 0x%08" PRIX32 " size: %" PRIu32 "\n", Flags, DstSize);
156 
157  if (DstSize != expectedSize)
158  {
159  printf("test_ZGfxDecompressFoxSingle: output size mismatch: Actual: %" PRIu32
160  ", Expected: %" PRIu32 "\n",
161  DstSize, expectedSize);
162  goto fail;
163  }
164 
165  if (memcmp(pDstData, TEST_FOX_DATA, DstSize) != 0)
166  {
167  printf("test_ZGfxDecompressFoxSingle: output mismatch\n");
168  printf("Actual\n");
169  BitDump(__func__, WLOG_INFO, pDstData, DstSize * 8, 0);
170  printf("Expected\n");
171  BitDump(__func__, WLOG_INFO, TEST_FOX_DATA, DstSize * 8, 0);
172  goto fail;
173  }
174 
175  rc = 0;
176 fail:
177  free(pDstData);
178  zgfx_context_free(zgfx);
179  return rc;
180 }
181 
182 static int test_ZGfxCompressConsistent(void)
183 {
184  int rc = -1;
185  int status = 0;
186 
187  UINT32 Flags = 0;
188  const BYTE* pSrcData = NULL;
189  UINT32 SrcSize = 0;
190  UINT32 DstSize = 0;
191  BYTE* pDstData = NULL;
192  UINT32 DstSize2 = 0;
193  BYTE* pDstData2 = NULL;
194  ZGFX_CONTEXT* zgfx = NULL;
195  UINT32 expectedSize = 0;
196  BYTE BigBuffer[65536];
197  memset(BigBuffer, 0xaa, sizeof(BigBuffer));
198  memcpy(BigBuffer, TEST_FOX_DATA, sizeof(TEST_FOX_DATA) - 1);
199  zgfx = zgfx_context_new(TRUE);
200 
201  if (!zgfx)
202  return -1;
203 
204  /* Compress */
205  expectedSize = SrcSize = sizeof(BigBuffer);
206  pSrcData = (const BYTE*)BigBuffer;
207  Flags = 0;
208  status = zgfx_compress(zgfx, pSrcData, SrcSize, &pDstData2, &DstSize2, &Flags);
209 
210  if (status < 0)
211  goto fail;
212 
213  printf("Compress: flags: 0x%08" PRIX32 " size: %" PRIu32 "\n", Flags, DstSize2);
214  /* Decompress */
215  status = zgfx_decompress(zgfx, pDstData2, DstSize2, &pDstData, &DstSize, Flags);
216 
217  if (status < 0)
218  goto fail;
219 
220  printf("Decompress: flags: 0x%08" PRIX32 " size: %" PRIu32 "\n", Flags, DstSize);
221 
222  if (DstSize != expectedSize)
223  {
224  printf("test_ZGfxDecompressFoxSingle: output size mismatch: Actual: %" PRIu32
225  ", Expected: %" PRIu32 "\n",
226  DstSize, expectedSize);
227  goto fail;
228  }
229 
230  if (memcmp(pDstData, BigBuffer, DstSize) != 0)
231  {
232  printf("test_ZGfxDecompressFoxSingle: output mismatch\n");
233  printf("Actual\n");
234  BitDump(__func__, WLOG_INFO, pDstData, 64 * 8, 0);
235  printf("...\n");
236  BitDump(__func__, WLOG_INFO, pDstData + DstSize - 64, 64 * 8, 0);
237  printf("Expected\n");
238  BitDump(__func__, WLOG_INFO, BigBuffer, 64 * 8, 0);
239  printf("...\n");
240  BitDump(__func__, WLOG_INFO, BigBuffer + DstSize - 64, 64 * 8, 0);
241  printf("Middle Result\n");
242  BitDump(__func__, WLOG_INFO, pDstData2, 64 * 8, 0);
243  printf("...\n");
244  BitDump(__func__, WLOG_INFO, pDstData2 + DstSize2 - 64, 64 * 8, 0);
245  goto fail;
246  }
247 
248  rc = 0;
249 fail:
250  free(pDstData);
251  free(pDstData2);
252  zgfx_context_free(zgfx);
253  return rc;
254 }
255 
256 int TestFreeRDPCodecZGfx(int argc, char* argv[])
257 {
258  WINPR_UNUSED(argc);
259  WINPR_UNUSED(argv);
260 
261  if (test_ZGfxCompressFox() < 0)
262  return -1;
263 
264  if (test_ZGfxDecompressFoxSingle() < 0)
265  return -1;
266 
267  if (test_ZGfxDecompressFoxMultipart() < 0)
268  return -1;
269 
270  if (test_ZGfxCompressConsistent() < 0)
271  return -1;
272 
273  return 0;
274 }