Commit | Line | Data |
---|---|---|
f64122c1 DA |
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 | } |