primitives.c (11630B)
1 /* 2 * Copyright © 2018 Broadcom 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24 /** @file 25 * 26 * Touch-testing of the damage extension's implementation of various 27 * primitives. The core initializes the pixmap with some contents, 28 * turns on damage and each per-primitive test gets to just make a 29 * rendering call that draws some pixels. Afterwards, the core checks 30 * what pixels were modified and makes sure the damage report contains 31 * them. 32 */ 33 34 /* Test relies on assert() */ 35 #undef NDEBUG 36 37 #include <assert.h> 38 #include <stdbool.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <string.h> 42 #include <limits.h> 43 #include <xcb/damage.h> 44 45 struct test_setup { 46 xcb_connection_t *c; 47 xcb_drawable_t d; 48 xcb_drawable_t start_drawable; 49 uint32_t *start_drawable_contents; 50 xcb_screen_t *screen; 51 xcb_gc_t gc; 52 int width, height; 53 uint32_t *expected; 54 uint32_t *damaged; 55 }; 56 57 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 58 59 /** 60 * Performs a synchronous GetImage for a test pixmap, returning 61 * uint32_t per pixel. 62 */ 63 static uint32_t * 64 get_image(struct test_setup *setup, xcb_drawable_t drawable) 65 { 66 xcb_get_image_cookie_t cookie = 67 xcb_get_image(setup->c, XCB_IMAGE_FORMAT_Z_PIXMAP, drawable, 68 0, 0, setup->width, setup->height, ~0); 69 xcb_get_image_reply_t *reply = 70 xcb_get_image_reply(setup->c, cookie, NULL); 71 uint8_t *data = xcb_get_image_data(reply); 72 int len = xcb_get_image_data_length(reply); 73 74 /* Do I understand X protocol and our test environment? */ 75 assert(reply->depth == 24); 76 assert(len == 4 * setup->width * setup->height); 77 78 uint32_t *result = malloc(sizeof(uint32_t) * 79 setup->width * setup->height); 80 memcpy(result, data, len); 81 free(reply); 82 83 return result; 84 } 85 86 /** 87 * Gets the image drawn by the test and compares it to the starting 88 * image, producing a bitmask of what pixels were damaged. 89 */ 90 static void 91 compute_expected_damage(struct test_setup *setup) 92 { 93 uint32_t *results = get_image(setup, setup->d); 94 bool any_modified_pixels = false; 95 96 for (int i = 0; i < setup->width * setup->height; i++) { 97 if (results[i] != setup->start_drawable_contents[i]) { 98 setup->expected[i / 32] |= 1 << (i % 32); 99 any_modified_pixels = true; 100 } 101 } 102 103 /* Make sure that the testcases actually render something! */ 104 assert(any_modified_pixels); 105 } 106 107 /** 108 * Processes a damage event, filling in the bitmask of pixels reported 109 * to be damaged. 110 */ 111 static bool 112 damage_event_handle(struct test_setup *setup, 113 struct xcb_damage_notify_event_t *event) 114 { 115 xcb_rectangle_t *rect = &event->area; 116 assert(event->drawable == setup->d); 117 for (int y = rect->y; y < rect->y + rect->height; y++) { 118 for (int x = rect->x; x < rect->x + rect->width; x++) { 119 int bit = y * setup->width + x; 120 setup->damaged[bit / 32] |= 1 << (bit % 32); 121 } 122 } 123 124 return event->level & 0x80; /* XXX: MORE is missing from xcb. */ 125 } 126 127 /** 128 * Collects a series of damage events (while the MORE flag is set) 129 * into the damaged bitmask. 130 */ 131 static void 132 collect_damage(struct test_setup *setup) 133 { 134 const xcb_query_extension_reply_t *ext = 135 xcb_get_extension_data(setup->c, &xcb_damage_id); 136 xcb_generic_event_t *ge; 137 138 xcb_flush(setup->c); 139 while ((ge = xcb_wait_for_event(setup->c))) { 140 int event = ge->response_type & ~0x80; 141 142 if (event == (ext->first_event + XCB_DAMAGE_NOTIFY)) { 143 if (!damage_event_handle(setup, 144 (struct xcb_damage_notify_event_t *)ge)) { 145 return; 146 } 147 } else { 148 switch (ge->response_type) { 149 case 0: { 150 xcb_generic_error_t *error = (xcb_generic_error_t *)ge; 151 fprintf(stderr, "X error %d at sequence %d\n", 152 error->error_code, error->sequence); 153 exit(1); 154 } 155 156 case XCB_GRAPHICS_EXPOSURE: 157 case XCB_NO_EXPOSURE: 158 break; 159 160 default: 161 fprintf(stderr, "Unexpected event %d\n", ge->response_type); 162 exit(1); 163 } 164 } 165 } 166 167 fprintf(stderr, "I/O error\n"); 168 exit(1); 169 } 170 171 /** 172 * Wrapper to set up the test pixmap, attach damage to it, and see if 173 * the reported damage matches the testcase's rendering. 174 */ 175 static bool 176 damage_test(struct test_setup *setup, 177 void (*test)(struct test_setup *setup), 178 const char *name) 179 { 180 uint32_t expected[32] = { 0 }; 181 uint32_t damaged[32] = { 0 }; 182 183 printf("Testing %s\n", name); 184 185 setup->expected = expected; 186 setup->damaged = damaged; 187 188 /* Create our pixmap for this test and fill it with the 189 * starting image. 190 */ 191 setup->d = xcb_generate_id(setup->c); 192 xcb_create_pixmap(setup->c, setup->screen->root_depth, 193 setup->d, setup->screen->root, 194 setup->width, setup->height); 195 196 setup->gc = xcb_generate_id(setup->c); 197 uint32_t values[] = { setup->screen->black_pixel }; 198 xcb_create_gc(setup->c, setup->gc, setup->screen->root, 199 XCB_GC_FOREGROUND, values); 200 201 xcb_copy_area(setup->c, 202 setup->start_drawable, 203 setup->d, 204 setup->gc, 205 0, 0, 206 0, 0, 207 setup->width, setup->height); 208 209 /* Start watching for damage now that we have the initial contents. */ 210 xcb_damage_damage_t damage = xcb_generate_id(setup->c); 211 xcb_damage_create(setup->c, damage, setup->d, 212 XCB_DAMAGE_REPORT_LEVEL_RAW_RECTANGLES); 213 214 test(setup); 215 216 compute_expected_damage(setup); 217 218 xcb_damage_destroy(setup->c, damage); 219 xcb_free_gc(setup->c, setup->gc); 220 xcb_free_pixmap(setup->c, setup->d); 221 collect_damage(setup); 222 223 for (int bit = 0; bit < setup->width * setup->height; bit++) { 224 if ((expected[bit / 32] & (1 << bit % 32)) && 225 !(damaged[bit / 32] & (1 << bit % 32))) { 226 fprintf(stderr, " fail: %s(): Damage report missed %d, %d\n", 227 name, bit % setup->width, bit / setup->width); 228 return false; 229 } 230 } 231 232 return true; 233 } 234 235 /** 236 * Creates the pixmap of contents that will be the initial state of 237 * each test's drawable. 238 */ 239 static void 240 create_start_pixmap(struct test_setup *setup) 241 { 242 setup->start_drawable = xcb_generate_id(setup->c); 243 xcb_create_pixmap(setup->c, setup->screen->root_depth, 244 setup->start_drawable, setup->screen->root, 245 setup->width, setup->height); 246 247 /* Fill pixmap so it has defined contents */ 248 xcb_gc_t fill = xcb_generate_id(setup->c); 249 uint32_t fill_values[] = { setup->screen->white_pixel }; 250 xcb_create_gc(setup->c, fill, setup->screen->root, 251 XCB_GC_FOREGROUND, fill_values); 252 253 xcb_rectangle_t rect_all = { 0, 0, setup->width, setup->height}; 254 xcb_poly_fill_rectangle(setup->c, setup->start_drawable, 255 fill, 1, &rect_all); 256 xcb_free_gc(setup->c, fill); 257 258 /* Draw a rectangle */ 259 xcb_gc_t gc = xcb_generate_id(setup->c); 260 uint32_t values[] = { 0xaaaaaaaa }; 261 xcb_create_gc(setup->c, gc, setup->screen->root, 262 XCB_GC_FOREGROUND, values); 263 264 xcb_rectangle_t rect = { 5, 5, 10, 15 }; 265 xcb_poly_rectangle(setup->c, setup->start_drawable, gc, 1, &rect); 266 267 xcb_free_gc(setup->c, gc); 268 269 /* Capture the rendered start contents once, for comparing each 270 * test's rendering output to the start contents. 271 */ 272 setup->start_drawable_contents = get_image(setup, setup->start_drawable); 273 } 274 275 static void 276 test_poly_point_origin(struct test_setup *setup) 277 { 278 struct xcb_point_t points[] = { {1, 2}, {3, 4} }; 279 xcb_poly_point(setup->c, XCB_COORD_MODE_ORIGIN, setup->d, setup->gc, 280 ARRAY_SIZE(points), points); 281 } 282 283 static void 284 test_poly_point_previous(struct test_setup *setup) 285 { 286 struct xcb_point_t points[] = { {1, 2}, {3, 4} }; 287 xcb_poly_point(setup->c, XCB_COORD_MODE_PREVIOUS, setup->d, setup->gc, 288 ARRAY_SIZE(points), points); 289 } 290 291 static void 292 test_poly_line_origin(struct test_setup *setup) 293 { 294 struct xcb_point_t points[] = { {1, 2}, {3, 4}, {5, 6} }; 295 xcb_poly_line(setup->c, XCB_COORD_MODE_ORIGIN, setup->d, setup->gc, 296 ARRAY_SIZE(points), points); 297 } 298 299 static void 300 test_poly_line_previous(struct test_setup *setup) 301 { 302 struct xcb_point_t points[] = { {1, 2}, {3, 4}, {5, 6} }; 303 xcb_poly_line(setup->c, XCB_COORD_MODE_PREVIOUS, setup->d, setup->gc, 304 ARRAY_SIZE(points), points); 305 } 306 307 static void 308 test_poly_fill_rectangle(struct test_setup *setup) 309 { 310 struct xcb_rectangle_t rects[] = { {1, 2, 3, 4}, 311 {5, 6, 7, 8} }; 312 xcb_poly_fill_rectangle(setup->c, setup->d, setup->gc, 313 ARRAY_SIZE(rects), rects); 314 } 315 316 static void 317 test_poly_rectangle(struct test_setup *setup) 318 { 319 struct xcb_rectangle_t rects[] = { {1, 2, 3, 4}, 320 {5, 6, 7, 8} }; 321 xcb_poly_rectangle(setup->c, setup->d, setup->gc, 322 ARRAY_SIZE(rects), rects); 323 } 324 325 static void 326 test_poly_segment(struct test_setup *setup) 327 { 328 struct xcb_segment_t segs[] = { {1, 2, 3, 4}, 329 {5, 6, 7, 8} }; 330 xcb_poly_segment(setup->c, setup->d, setup->gc, 331 ARRAY_SIZE(segs), segs); 332 } 333 334 int main(int argc, char **argv) 335 { 336 int screen; 337 xcb_connection_t *c = xcb_connect(NULL, &screen); 338 const xcb_query_extension_reply_t *ext = 339 xcb_get_extension_data(c, &xcb_damage_id); 340 341 if (!ext->present) { 342 printf("No XDamage present\n"); 343 exit(77); 344 } 345 346 struct test_setup setup = { 347 .c = c, 348 .width = 32, 349 .height = 32, 350 }; 351 352 /* Get the screen so we have the root window. */ 353 xcb_screen_iterator_t iter; 354 iter = xcb_setup_roots_iterator (xcb_get_setup (c)); 355 setup.screen = iter.data; 356 357 xcb_damage_query_version(c, 1, 1); 358 359 create_start_pixmap(&setup); 360 361 bool pass = true; 362 #define test(x) pass = damage_test(&setup, x, #x) && pass; 363 364 test(test_poly_point_origin); 365 test(test_poly_point_previous); 366 test(test_poly_line_origin); 367 test(test_poly_line_previous); 368 test(test_poly_fill_rectangle); 369 test(test_poly_rectangle); 370 test(test_poly_segment); 371 372 xcb_disconnect(c); 373 exit(pass ? 0 : 1); 374 }