1
2 #include "common_code.h"
3
4 #define QUOTIENT 0x04c11db7
5 #define MEMORY_POOL_SIZE (640 * 480 * 4)
6
7 #define SYSTEM_CLOCK 6000000
8 #define SYSTICK_CYCLES ((SYSTEM_CLOCK / 100) -1)
9 #define ONE_MILLION 1000000
10
11 static GX_BOOL generate = GX_FALSE;
12 static GX_BOOL test = GX_FALSE;
13 static GX_BOOL screenshot = GX_FALSE;
14 static UINT *golden_results = GX_NULL;
15 static UINT golden_results_size = 0;
16 static UINT test_count = 0;
17 static UINT failed_count = 0;
18 static UINT crc_table[256];
19 static FILE *canvas_fp = GX_NULL;
20 static FILE *golden_fp = GX_NULL;
21 static FILE *output_fp = GX_NULL;
22 static TX_BYTE_POOL memory_pool;
23 static GX_UBYTE memory_pool_buffer[MEMORY_POOL_SIZE];
24
25 extern int stdout_init (void);
26
27 /******************************************************************************************/
28 /* Define memory allocator function. */
29 /******************************************************************************************/
memory_allocate(ULONG size)30 VOID *memory_allocate(ULONG size)
31 {
32 VOID *memptr;
33
34 if (tx_byte_allocate(&memory_pool, &memptr, size, TX_NO_WAIT) == TX_SUCCESS)
35 {
36 return memptr;
37 }
38 return NULL;
39 }
40
41 /******************************************************************************************/
42 /* Define memory de-allocator function. */
43 /******************************************************************************************/
memory_free(VOID * mem)44 void memory_free(VOID *mem)
45 {
46 tx_byte_release(mem);
47 }
48
memory_pool_create()49 VOID memory_pool_create()
50 {
51 /* create byte pool for decode to use */
52 tx_byte_pool_create(&memory_pool, "scratchpad", memory_pool_buffer, MEMORY_POOL_SIZE);
53
54 /* install our memory allocator and de-allocator */
55 gx_system_memory_allocator_set(memory_allocate, memory_free);
56 }
57
display_buffer_toggle(GX_CANVAS * canvas,GX_RECTANGLE * dirty)58 VOID display_buffer_toggle(GX_CANVAS *canvas, GX_RECTANGLE *dirty)
59 {
60
61 }
62
graphics_driver_8bit_palette_set(GX_DISPLAY * display,GX_COLOR * palette,INT count)63 VOID graphics_driver_8bit_palette_set(GX_DISPLAY *display, GX_COLOR *palette, INT count)
64 {
65 display -> gx_display_palette = palette;
66 display -> gx_display_palette_size = count;
67 }
68
graphics_driver_565rgb_setup(GX_DISPLAY * display)69 UINT graphics_driver_565rgb_setup(GX_DISPLAY *display)
70 {
71 _gx_display_driver_565rgb_setup(display, GX_NULL, display_buffer_toggle);
72
73 return GX_SUCCESS;
74 }
75
graphics_driver_1555xrgb_setup(GX_DISPLAY * display)76 UINT graphics_driver_1555xrgb_setup(GX_DISPLAY *display)
77 {
78 _gx_display_driver_1555xrgb_setup(display, GX_NULL, display_buffer_toggle);
79
80 return GX_SUCCESS;
81 }
82
graphics_driver_24xrgb_setup(GX_DISPLAY * display)83 UINT graphics_driver_24xrgb_setup(GX_DISPLAY *display)
84 {
85 _gx_display_driver_24xrgb_setup(display, GX_NULL, display_buffer_toggle);
86
87 return GX_SUCCESS;
88 }
89
graphics_driver_8bit_palette_setup(GX_DISPLAY * display)90 UINT graphics_driver_8bit_palette_setup(GX_DISPLAY *display)
91 {
92 _gx_display_driver_8bit_palette_setup(display, GX_NULL, display_buffer_toggle);
93 display -> gx_display_driver_palette_set = graphics_driver_8bit_palette_set;
94
95 return GX_SUCCESS;
96 }
97
graphics_driver_565rgb_rotated_setup(GX_DISPLAY * display)98 UINT graphics_driver_565rgb_rotated_setup(GX_DISPLAY *display)
99 {
100 _gx_display_driver_565rgb_rotated_setup(display, GX_NULL, display_buffer_toggle);
101
102 return GX_SUCCESS;
103 }
104
graphics_driver_24xrgb_rotated_setup(GX_DISPLAY * display)105 UINT graphics_driver_24xrgb_rotated_setup(GX_DISPLAY *display)
106 {
107 _gx_display_driver_24xrgb_rotated_setup(display, GX_NULL, display_buffer_toggle);
108
109 return GX_SUCCESS;
110 }
111
graphics_driver_8bit_palette_rotated_setup(GX_DISPLAY * display)112 UINT graphics_driver_8bit_palette_rotated_setup(GX_DISPLAY *display)
113 {
114 _gx_display_driver_8bit_palette_rotated_setup(display, GX_NULL, display_buffer_toggle);
115 display -> gx_display_driver_palette_set = graphics_driver_8bit_palette_set;
116
117 return GX_SUCCESS;
118 }
119
write_data_callback(GX_UBYTE * byte_data,UINT data_count)120 UINT write_data_callback(GX_UBYTE *byte_data, UINT data_count)
121 {
122 if(canvas_fp)
123 {
124 fwrite(byte_data, 1, data_count, canvas_fp);
125 }
126
127 return GX_SUCCESS;
128 }
129
test_start(GX_BOOL g,GX_BOOL t,GX_BOOL s,UINT * results,UINT size)130 VOID test_start(GX_BOOL g, GX_BOOL t, GX_BOOL s, UINT *results, UINT size)
131 {
132 generate = g;
133 test = t;
134 screenshot = s;
135 golden_results = results;
136 golden_results_size = size;
137
138 stdout_init();
139 }
140
test_string_length_get(GX_CONST GX_CHAR * input_string,UINT max_string_length)141 static UINT test_string_length_get(GX_CONST GX_CHAR* input_string, UINT max_string_length)
142 {
143 UINT length = 0;
144
145 if (input_string)
146 {
147 /* Traverse the string. */
148 for (length = 0; input_string[length]; length++)
149 {
150 /* Check if the string length is bigger than the max string length. */
151 if (length >= max_string_length)
152 {
153 break;
154 }
155 }
156 }
157
158 return length;
159 }
160
test_verify_canvas(GX_CANVAS * canvas,INT frame_id)161 VOID test_verify_canvas(GX_CANVAS *canvas, INT frame_id)
162 {
163 UINT new_crc;
164 GX_RECTANGLE size;
165 GX_CHAR string[50];
166
167 if(screenshot)
168 {
169 sprintf(string, "frame_%d.bmp", frame_id);
170 canvas_fp = fopen (string, "w+");
171 gx_utility_rectangle_define(&size, 0, 0, canvas->gx_canvas_x_resolution - 1, canvas->gx_canvas_y_resolution - 1);
172 gx_utility_canvas_to_bmp(canvas, &size, write_data_callback);
173 fclose(canvas_fp);
174 canvas_fp = GX_NULL;
175 }
176
177 new_crc = crc_calculate((UCHAR *)canvas->gx_canvas_memory, canvas->gx_canvas_memory_size);
178
179 if(test)
180 {
181 if(!golden_results)
182 {
183 printf("golden results is missing!\r\n");
184 failed_count++;
185 }
186 else if(frame_id <= golden_results_size)
187 {
188 if(new_crc != golden_results[frame_id - 1])
189 {
190 printf("frame %d: failed\r\n", frame_id);
191 failed_count++;
192 }
193 else
194 {
195 printf("frame %d: passed\r\n", frame_id);
196 }
197 }
198 else
199 {
200 printf("frame %d: failed\r\n", frame_id);
201 failed_count++;
202 }
203
204 test_count++;
205 }
206
207 if(generate || test)
208 {
209 if(frame_id == 1)
210 {
211 if(generate)
212 {
213 golden_fp = fopen("golden_results.c", "w+");
214 }
215 if(test)
216 {
217 output_fp = fopen("output_results.c", "w+");
218 }
219 sprintf(string, "UINT golden_results[] ={\r\n 0x%x", new_crc);
220 }
221 else
222 {
223 sprintf(string, ",\r\n 0x%x", new_crc);
224 }
225
226 if(golden_fp)
227 {
228 fwrite(string, 1, test_string_length_get(string, 256), golden_fp);
229 }
230
231 if(output_fp)
232 {
233 fwrite(string, 1, test_string_length_get(string, 256), output_fp);
234 }
235 }
236 }
237
test_end()238 UINT test_end()
239 {
240 if(golden_fp)
241 {
242 fwrite("\r\n};", 1, 3, golden_fp);
243 fclose(golden_fp);
244 golden_fp = GX_NULL;
245 }
246
247 if(output_fp)
248 {
249 fwrite("\r\n};", 1, 3, output_fp);
250 fclose(output_fp);
251 output_fp = GX_NULL;
252 }
253
254 if(test)
255 {
256 printf("\r\nTests Passed: %d\r\n", test_count - failed_count);
257 printf("Tests Failed: %d\r\n", failed_count);
258
259 return failed_count;
260 }
261
262 return 0;
263 }
264
265 ///////////////////////////////////////////////////////////////////////////////
crc32_init(UINT * crc_table,INT size)266 void crc32_init(UINT *crc_table, INT size)
267 {
268 INT i;
269 INT j;
270 UINT crc;
271
272 for (i = 0; i < size; i++)
273 {
274 crc = i << 24;
275 for (j = 0; j < 8; j++)
276 {
277 if (crc & 0x80000000)
278 crc = (crc << 1) ^ QUOTIENT;
279 else
280 crc = crc << 1;
281 }
282 crc_table[i] = crc;
283 }
284 }
285
286 ///////////////////////////////////////////////////////////////////////////////
crc_calculate(UCHAR * data,INT len)287 UINT crc_calculate(UCHAR *data, INT len)
288 {
289 UINT result;
290 INT i;
291
292 crc32_init(crc_table, sizeof(crc_table)/sizeof(UINT));
293
294 result = *data++ << 24;
295 result |= *data++ << 16;
296 result |= *data++ << 8;
297 result |= *data++;
298 result = ~ result;
299 len -=4;
300
301 for (i=0; i<len; i++)
302 {
303 result = (result << 8 | *data++) ^ crc_table[result >> 24];
304 }
305
306 return ~result;
307 }
308
test_jpeg_to_canvas_draw(GX_CANVAS * canvas,GX_WINDOW * window,MAP_INFO * test,INT frame_id)309 VOID test_jpeg_to_canvas_draw(GX_CANVAS *canvas, GX_WINDOW *window, MAP_INFO *test, INT frame_id)
310 {
311 GX_PIXELMAP *map;
312 ULONG start_time;
313 ULONG ticks;
314
315 /* Test decode JPEG to canvas. */
316
317 gx_window_background_draw(window);
318 while(test->map_id)
319 {
320 gx_context_pixelmap_get(test->map_id, &map);
321 start_time = tx_time_get();
322 gx_canvas_pixelmap_draw(test->xpos, test->ypos, map);
323 ticks = tx_time_get() - start_time;
324 printf("JPEG to canvas. ID Name: %s, Dimension: %dx%d, cycle count = %ld.%ld(Million Cycles)\r\n\r\n", test->name, map->gx_pixelmap_width, map->gx_pixelmap_height, ticks * SYSTICK_CYCLES / ONE_MILLION, ticks * SYSTICK_CYCLES % ONE_MILLION);
325 test++;
326 }
327 test_verify_canvas(canvas, frame_id);
328 }
329
test_jpeg_to_pixelmap_draw(GX_CANVAS * canvas,GX_WINDOW * window,MAP_INFO * test,GX_UBYTE outformat,GX_UBYTE flags,INT frame_id)330 VOID test_jpeg_to_pixelmap_draw(GX_CANVAS *canvas, GX_WINDOW *window, MAP_INFO *test, GX_UBYTE outformat, GX_UBYTE flags, INT frame_id)
331 {
332 GX_PIXELMAP *map;
333 GX_IMAGE_READER image_reader;
334 GX_PIXELMAP outmap;
335 ULONG start_time;
336 ULONG ticks;
337
338 /* Test decode JPEG to pixelmap. */
339
340 gx_window_background_draw(window);
341 while(test->map_id)
342 {
343
344 gx_context_pixelmap_get(test->map_id, &map);
345
346 gx_image_reader_create(&image_reader, map->gx_pixelmap_data, map->gx_pixelmap_data_size, outformat, flags);
347
348 if(outformat == GX_COLOR_FORMAT_8BIT_PALETTE)
349 {
350 gx_image_reader_palette_set(&image_reader, canvas->gx_canvas_display->gx_display_palette, canvas->gx_canvas_display->gx_display_palette_size);
351 }
352
353 start_time = tx_time_get();
354 if(gx_image_reader_start(&image_reader, &outmap) == GX_SUCCESS)
355 {
356 ticks = tx_time_get() - start_time;
357 printf("JPGE to pixelmap. ID Name: %s, Dimension: %dx%d, cycle count = %ld.%ld(Million Cycles)\r\n\r\n", test->name, map->gx_pixelmap_width, map->gx_pixelmap_height, ticks * SYSTICK_CYCLES / ONE_MILLION, ticks * SYSTICK_CYCLES % ONE_MILLION);
358
359 gx_canvas_pixelmap_draw(test->xpos, test->ypos, &outmap);
360 memory_free((void *)outmap.gx_pixelmap_data);
361 }
362 else
363 {
364 printf("JPEG decode failure!\r\n");
365 }
366 test++;
367 }
368 test_verify_canvas(canvas, frame_id);
369 }
