1 /* 2 * Copyright 2011 Red Hat, Inc. 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 * on the rights to use, copy, modify, merge, publish, distribute, sub 8 * license, and/or sell copies of the Software, and to permit persons to whom 9 * the 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 NON-INFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 23 #include "qxl_drv.h" 24 #include "qxl_object.h" 25 26 /* returns a pointer to the already allocated qxl_rect array inside 27 * the qxl_clip_rects. This is *not* the same as the memory allocated 28 * on the device, it is offset to qxl_clip_rects.chunk.data */ 29 static struct qxl_rect *drawable_set_clipping(struct qxl_device *qdev, 30 struct qxl_drawable *drawable, 31 unsigned num_clips, 32 struct qxl_bo **clips_bo, 33 struct qxl_release *release) 34 { 35 struct qxl_clip_rects *dev_clips; 36 int ret; 37 int size = sizeof(*dev_clips) + sizeof(struct qxl_rect) * num_clips; 38 ret = qxl_alloc_bo_reserved(qdev, size, clips_bo); 39 if (ret) 40 return NULL; 41 42 ret = qxl_bo_kmap(*clips_bo, (void **)&dev_clips); 43 if (ret) { 44 qxl_bo_unref(clips_bo); 45 return NULL; 46 } 47 dev_clips->num_rects = num_clips; 48 dev_clips->chunk.next_chunk = 0; 49 dev_clips->chunk.prev_chunk = 0; 50 dev_clips->chunk.data_size = sizeof(struct qxl_rect) * num_clips; 51 return (struct qxl_rect *)dev_clips->chunk.data; 52 } 53 54 static int 55 make_drawable(struct qxl_device *qdev, int surface, uint8_t type, 56 const struct qxl_rect *rect, 57 struct qxl_release **release) 58 { 59 struct qxl_drawable *drawable; 60 int i, ret; 61 62 ret = qxl_alloc_release_reserved(qdev, sizeof(*drawable), 63 QXL_RELEASE_DRAWABLE, release, 64 NULL); 65 if (ret) 66 return ret; 67 68 drawable = (struct qxl_drawable *)qxl_release_map(qdev, *release); 69 drawable->type = type; 70 71 drawable->surface_id = surface; /* Only primary for now */ 72 drawable->effect = QXL_EFFECT_OPAQUE; 73 drawable->self_bitmap = 0; 74 drawable->self_bitmap_area.top = 0; 75 drawable->self_bitmap_area.left = 0; 76 drawable->self_bitmap_area.bottom = 0; 77 drawable->self_bitmap_area.right = 0; 78 /* FIXME: add clipping */ 79 drawable->clip.type = SPICE_CLIP_TYPE_NONE; 80 81 /* 82 * surfaces_dest[i] should apparently be filled out with the 83 * surfaces that we depend on, and surface_rects should be 84 * filled with the rectangles of those surfaces that we 85 * are going to use. 86 */ 87 for (i = 0; i < 3; ++i) 88 drawable->surfaces_dest[i] = -1; 89 90 if (rect) 91 drawable->bbox = *rect; 92 93 drawable->mm_time = qdev->rom->mm_clock; 94 qxl_release_unmap(qdev, *release, &drawable->release_info); 95 return 0; 96 } 97 98 static int qxl_palette_create_1bit(struct qxl_bo **palette_bo, 99 const struct qxl_fb_image *qxl_fb_image) 100 { 101 struct qxl_device *qdev = qxl_fb_image->qdev; 102 const struct fb_image *fb_image = &qxl_fb_image->fb_image; 103 uint32_t visual = qxl_fb_image->visual; 104 const uint32_t *pseudo_palette = qxl_fb_image->pseudo_palette; 105 struct qxl_palette *pal; 106 int ret; 107 uint32_t fgcolor, bgcolor; 108 static uint64_t unique; /* we make no attempt to actually set this 109 * correctly globaly, since that would require 110 * tracking all of our palettes. */ 111 112 ret = qxl_alloc_bo_reserved(qdev, 113 sizeof(struct qxl_palette) + sizeof(uint32_t) * 2, 114 palette_bo); 115 116 ret = qxl_bo_kmap(*palette_bo, (void **)&pal); 117 pal->num_ents = 2; 118 pal->unique = unique++; 119 if (visual == FB_VISUAL_TRUECOLOR || visual == FB_VISUAL_DIRECTCOLOR) { 120 /* NB: this is the only used branch currently. */ 121 fgcolor = pseudo_palette[fb_image->fg_color]; 122 bgcolor = pseudo_palette[fb_image->bg_color]; 123 } else { 124 fgcolor = fb_image->fg_color; 125 bgcolor = fb_image->bg_color; 126 } 127 pal->ents[0] = bgcolor; 128 pal->ents[1] = fgcolor; 129 qxl_bo_kunmap(*palette_bo); 130 return 0; 131 } 132 133 void qxl_draw_opaque_fb(const struct qxl_fb_image *qxl_fb_image, 134 int stride /* filled in if 0 */) 135 { 136 struct qxl_device *qdev = qxl_fb_image->qdev; 137 struct qxl_drawable *drawable; 138 struct qxl_rect rect; 139 const struct fb_image *fb_image = &qxl_fb_image->fb_image; 140 int x = fb_image->dx; 141 int y = fb_image->dy; 142 int width = fb_image->width; 143 int height = fb_image->height; 144 const char *src = fb_image->data; 145 int depth = fb_image->depth; 146 struct qxl_release *release; 147 struct qxl_bo *image_bo; 148 struct qxl_image *image; 149 int ret; 150 151 if (stride == 0) 152 stride = depth * width / 8; 153 154 rect.left = x; 155 rect.right = x + width; 156 rect.top = y; 157 rect.bottom = y + height; 158 159 ret = make_drawable(qdev, 0, QXL_DRAW_COPY, &rect, &release); 160 if (ret) 161 return; 162 163 ret = qxl_image_create(qdev, release, &image_bo, 164 (const uint8_t *)src, 0, 0, 165 width, height, depth, stride); 166 if (ret) { 167 qxl_release_unreserve(qdev, release); 168 qxl_release_free(qdev, release); 169 return; 170 } 171 172 if (depth == 1) { 173 struct qxl_bo *palette_bo; 174 void *ptr; 175 ret = qxl_palette_create_1bit(&palette_bo, qxl_fb_image); 176 qxl_release_add_res(qdev, release, palette_bo); 177 178 ptr = qxl_bo_kmap_atomic_page(qdev, image_bo, 0); 179 image = ptr; 180 image->u.bitmap.palette = 181 qxl_bo_physical_address(qdev, palette_bo, 0); 182 qxl_bo_kunmap_atomic_page(qdev, image_bo, ptr); 183 qxl_bo_unreserve(palette_bo); 184 qxl_bo_unref(&palette_bo); 185 } 186 187 drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); 188 189 drawable->u.copy.src_area.top = 0; 190 drawable->u.copy.src_area.bottom = height; 191 drawable->u.copy.src_area.left = 0; 192 drawable->u.copy.src_area.right = width; 193 194 drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT; 195 drawable->u.copy.scale_mode = 0; 196 drawable->u.copy.mask.flags = 0; 197 drawable->u.copy.mask.pos.x = 0; 198 drawable->u.copy.mask.pos.y = 0; 199 drawable->u.copy.mask.bitmap = 0; 200 201 drawable->u.copy.src_bitmap = 202 qxl_bo_physical_address(qdev, image_bo, 0); 203 qxl_release_unmap(qdev, release, &drawable->release_info); 204 205 qxl_release_add_res(qdev, release, image_bo); 206 qxl_bo_unreserve(image_bo); 207 qxl_bo_unref(&image_bo); 208 209 qxl_fence_releaseable(qdev, release); 210 qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); 211 qxl_release_unreserve(qdev, release); 212 } 213 214 /* push a draw command using the given clipping rectangles as 215 * the sources from the shadow framebuffer. 216 * 217 * Right now implementing with a single draw and a clip list. Clip 218 * lists are known to be a problem performance wise, this can be solved 219 * by treating them differently in the server. 220 */ 221 void qxl_draw_dirty_fb(struct qxl_device *qdev, 222 struct qxl_framebuffer *qxl_fb, 223 struct qxl_bo *bo, 224 unsigned flags, unsigned color, 225 struct drm_clip_rect *clips, 226 unsigned num_clips, int inc) 227 { 228 /* 229 * TODO: if flags & DRM_MODE_FB_DIRTY_ANNOTATE_FILL then we should 230 * send a fill command instead, much cheaper. 231 * 232 * See include/drm/drm_mode.h 233 */ 234 struct drm_clip_rect *clips_ptr; 235 int i; 236 int left, right, top, bottom; 237 int width, height; 238 struct qxl_drawable *drawable; 239 struct qxl_rect drawable_rect; 240 struct qxl_rect *rects; 241 int stride = qxl_fb->base.pitches[0]; 242 /* depth is not actually interesting, we don't mask with it */ 243 int depth = qxl_fb->base.bits_per_pixel; 244 uint8_t *surface_base; 245 struct qxl_release *release; 246 struct qxl_bo *image_bo; 247 struct qxl_bo *clips_bo; 248 int ret; 249 250 left = clips->x1; 251 right = clips->x2; 252 top = clips->y1; 253 bottom = clips->y2; 254 255 /* skip the first clip rect */ 256 for (i = 1, clips_ptr = clips + inc; 257 i < num_clips; i++, clips_ptr += inc) { 258 left = min_t(int, left, (int)clips_ptr->x1); 259 right = max_t(int, right, (int)clips_ptr->x2); 260 top = min_t(int, top, (int)clips_ptr->y1); 261 bottom = max_t(int, bottom, (int)clips_ptr->y2); 262 } 263 264 width = right - left; 265 height = bottom - top; 266 drawable_rect.left = left; 267 drawable_rect.right = right; 268 drawable_rect.top = top; 269 drawable_rect.bottom = bottom; 270 ret = make_drawable(qdev, 0, QXL_DRAW_COPY, &drawable_rect, 271 &release); 272 if (ret) 273 return; 274 275 ret = qxl_bo_kmap(bo, (void **)&surface_base); 276 if (ret) 277 goto out_unref; 278 279 ret = qxl_image_create(qdev, release, &image_bo, surface_base, 280 left, top, width, height, depth, stride); 281 qxl_bo_kunmap(bo); 282 if (ret) 283 goto out_unref; 284 285 rects = drawable_set_clipping(qdev, drawable, num_clips, &clips_bo, release); 286 if (!rects) { 287 qxl_bo_unref(&image_bo); 288 goto out_unref; 289 } 290 drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); 291 292 drawable->clip.type = SPICE_CLIP_TYPE_RECTS; 293 drawable->clip.data = qxl_bo_physical_address(qdev, 294 clips_bo, 0); 295 qxl_release_add_res(qdev, release, clips_bo); 296 297 drawable->u.copy.src_area.top = 0; 298 drawable->u.copy.src_area.bottom = height; 299 drawable->u.copy.src_area.left = 0; 300 drawable->u.copy.src_area.right = width; 301 302 drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT; 303 drawable->u.copy.scale_mode = 0; 304 drawable->u.copy.mask.flags = 0; 305 drawable->u.copy.mask.pos.x = 0; 306 drawable->u.copy.mask.pos.y = 0; 307 drawable->u.copy.mask.bitmap = 0; 308 309 drawable->u.copy.src_bitmap = qxl_bo_physical_address(qdev, image_bo, 0); 310 qxl_release_unmap(qdev, release, &drawable->release_info); 311 qxl_release_add_res(qdev, release, image_bo); 312 qxl_bo_unreserve(image_bo); 313 qxl_bo_unref(&image_bo); 314 clips_ptr = clips; 315 for (i = 0; i < num_clips; i++, clips_ptr += inc) { 316 rects[i].left = clips_ptr->x1; 317 rects[i].right = clips_ptr->x2; 318 rects[i].top = clips_ptr->y1; 319 rects[i].bottom = clips_ptr->y2; 320 } 321 qxl_bo_kunmap(clips_bo); 322 qxl_bo_unreserve(clips_bo); 323 qxl_bo_unref(&clips_bo); 324 325 qxl_fence_releaseable(qdev, release); 326 qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); 327 qxl_release_unreserve(qdev, release); 328 return; 329 330 out_unref: 331 qxl_release_unreserve(qdev, release); 332 qxl_release_free(qdev, release); 333 } 334 335 void qxl_draw_copyarea(struct qxl_device *qdev, 336 u32 width, u32 height, 337 u32 sx, u32 sy, 338 u32 dx, u32 dy) 339 { 340 struct qxl_drawable *drawable; 341 struct qxl_rect rect; 342 struct qxl_release *release; 343 int ret; 344 345 rect.left = dx; 346 rect.top = dy; 347 rect.right = dx + width; 348 rect.bottom = dy + height; 349 ret = make_drawable(qdev, 0, QXL_COPY_BITS, &rect, &release); 350 if (ret) 351 return; 352 353 drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); 354 drawable->u.copy_bits.src_pos.x = sx; 355 drawable->u.copy_bits.src_pos.y = sy; 356 357 qxl_release_unmap(qdev, release, &drawable->release_info); 358 qxl_fence_releaseable(qdev, release); 359 qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); 360 qxl_release_unreserve(qdev, release); 361 } 362 363 void qxl_draw_fill(struct qxl_draw_fill *qxl_draw_fill_rec) 364 { 365 struct qxl_device *qdev = qxl_draw_fill_rec->qdev; 366 struct qxl_rect rect = qxl_draw_fill_rec->rect; 367 uint32_t color = qxl_draw_fill_rec->color; 368 uint16_t rop = qxl_draw_fill_rec->rop; 369 struct qxl_drawable *drawable; 370 struct qxl_release *release; 371 int ret; 372 373 ret = make_drawable(qdev, 0, QXL_DRAW_FILL, &rect, &release); 374 if (ret) 375 return; 376 377 drawable = (struct qxl_drawable *)qxl_release_map(qdev, release); 378 drawable->u.fill.brush.type = SPICE_BRUSH_TYPE_SOLID; 379 drawable->u.fill.brush.u.color = color; 380 drawable->u.fill.rop_descriptor = rop; 381 drawable->u.fill.mask.flags = 0; 382 drawable->u.fill.mask.pos.x = 0; 383 drawable->u.fill.mask.pos.y = 0; 384 drawable->u.fill.mask.bitmap = 0; 385 386 qxl_release_unmap(qdev, release, &drawable->release_info); 387 qxl_fence_releaseable(qdev, release); 388 qxl_push_command_ring_release(qdev, release, QXL_CMD_DRAW, false); 389 qxl_release_unreserve(qdev, release); 390 } 391