Line data Source code
1 : /*
2 : * Copyright (C) 2011-2013 Intel Corporation
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 FROM,
20 : * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 : * SOFTWARE.
22 : */
23 :
24 : #include <linux/errno.h>
25 : #include <linux/export.h>
26 : #include <linux/kernel.h>
27 :
28 : #include <drm/drm_mode.h>
29 : #include <drm/drm_print.h>
30 : #include <drm/drm_rect.h>
31 :
32 : /**
33 : * drm_rect_intersect - intersect two rectangles
34 : * @r1: first rectangle
35 : * @r2: second rectangle
36 : *
37 : * Calculate the intersection of rectangles @r1 and @r2.
38 : * @r1 will be overwritten with the intersection.
39 : *
40 : * RETURNS:
41 : * %true if rectangle @r1 is still visible after the operation,
42 : * %false otherwise.
43 : */
44 26 : bool drm_rect_intersect(struct drm_rect *r1, const struct drm_rect *r2)
45 : {
46 26 : r1->x1 = max(r1->x1, r2->x1);
47 26 : r1->y1 = max(r1->y1, r2->y1);
48 26 : r1->x2 = min(r1->x2, r2->x2);
49 26 : r1->y2 = min(r1->y2, r2->y2);
50 :
51 26 : return drm_rect_visible(r1);
52 : }
53 : EXPORT_SYMBOL(drm_rect_intersect);
54 :
55 : static u32 clip_scaled(int src, int dst, int *clip)
56 : {
57 : u64 tmp;
58 :
59 34 : if (dst == 0)
60 : return 0;
61 :
62 : /* Only clip what we have. Keeps the result bounded. */
63 30 : *clip = min(*clip, dst);
64 :
65 60 : tmp = mul_u32_u32(src, dst - *clip);
66 :
67 : /*
68 : * Round toward 1.0 when clipping so that we don't accidentally
69 : * change upscaling to downscaling or vice versa.
70 : */
71 30 : if (src < (dst << 16))
72 8 : return DIV_ROUND_UP_ULL(tmp, dst);
73 : else
74 22 : return DIV_ROUND_DOWN_ULL(tmp, dst);
75 : }
76 :
77 : /**
78 : * drm_rect_clip_scaled - perform a scaled clip operation
79 : * @src: source window rectangle
80 : * @dst: destination window rectangle
81 : * @clip: clip rectangle
82 : *
83 : * Clip rectangle @dst by rectangle @clip. Clip rectangle @src by
84 : * the corresponding amounts, retaining the vertical and horizontal scaling
85 : * factors from @src to @dst.
86 : *
87 : * RETURNS:
88 : *
89 : * %true if rectangle @dst is still visible after being clipped,
90 : * %false otherwise.
91 : */
92 22 : bool drm_rect_clip_scaled(struct drm_rect *src, struct drm_rect *dst,
93 : const struct drm_rect *clip)
94 : {
95 : int diff;
96 :
97 22 : diff = clip->x1 - dst->x1;
98 22 : if (diff > 0) {
99 28 : u32 new_src_w = clip_scaled(drm_rect_width(src),
100 : drm_rect_width(dst), &diff);
101 :
102 7 : src->x1 = src->x2 - new_src_w;
103 7 : dst->x1 += diff;
104 : }
105 22 : diff = clip->y1 - dst->y1;
106 22 : if (diff > 0) {
107 28 : u32 new_src_h = clip_scaled(drm_rect_height(src),
108 : drm_rect_height(dst), &diff);
109 :
110 7 : src->y1 = src->y2 - new_src_h;
111 7 : dst->y1 += diff;
112 : }
113 22 : diff = dst->x2 - clip->x2;
114 22 : if (diff > 0) {
115 40 : u32 new_src_w = clip_scaled(drm_rect_width(src),
116 : drm_rect_width(dst), &diff);
117 :
118 10 : src->x2 = src->x1 + new_src_w;
119 10 : dst->x2 -= diff;
120 : }
121 22 : diff = dst->y2 - clip->y2;
122 22 : if (diff > 0) {
123 40 : u32 new_src_h = clip_scaled(drm_rect_height(src),
124 : drm_rect_height(dst), &diff);
125 :
126 10 : src->y2 = src->y1 + new_src_h;
127 10 : dst->y2 -= diff;
128 : }
129 :
130 22 : return drm_rect_visible(dst);
131 : }
132 : EXPORT_SYMBOL(drm_rect_clip_scaled);
133 :
134 34 : static int drm_calc_scale(int src, int dst)
135 : {
136 34 : int scale = 0;
137 :
138 34 : if (WARN_ON(src < 0 || dst < 0))
139 : return -EINVAL;
140 :
141 30 : if (dst == 0)
142 : return 0;
143 :
144 30 : if (src > (dst << 16))
145 14 : return DIV_ROUND_UP(src, dst);
146 : else
147 16 : scale = src / dst;
148 :
149 16 : return scale;
150 : }
151 :
152 : /**
153 : * drm_rect_calc_hscale - calculate the horizontal scaling factor
154 : * @src: source window rectangle
155 : * @dst: destination window rectangle
156 : * @min_hscale: minimum allowed horizontal scaling factor
157 : * @max_hscale: maximum allowed horizontal scaling factor
158 : *
159 : * Calculate the horizontal scaling factor as
160 : * (@src width) / (@dst width).
161 : *
162 : * If the scale is below 1 << 16, round down. If the scale is above
163 : * 1 << 16, round up. This will calculate the scale with the most
164 : * pessimistic limit calculation.
165 : *
166 : * RETURNS:
167 : * The horizontal scaling factor, or errno of out of limits.
168 : */
169 17 : int drm_rect_calc_hscale(const struct drm_rect *src,
170 : const struct drm_rect *dst,
171 : int min_hscale, int max_hscale)
172 : {
173 34 : int src_w = drm_rect_width(src);
174 34 : int dst_w = drm_rect_width(dst);
175 17 : int hscale = drm_calc_scale(src_w, dst_w);
176 :
177 17 : if (hscale < 0 || dst_w == 0)
178 : return hscale;
179 :
180 15 : if (hscale < min_hscale || hscale > max_hscale)
181 : return -ERANGE;
182 :
183 11 : return hscale;
184 : }
185 : EXPORT_SYMBOL(drm_rect_calc_hscale);
186 :
187 : /**
188 : * drm_rect_calc_vscale - calculate the vertical scaling factor
189 : * @src: source window rectangle
190 : * @dst: destination window rectangle
191 : * @min_vscale: minimum allowed vertical scaling factor
192 : * @max_vscale: maximum allowed vertical scaling factor
193 : *
194 : * Calculate the vertical scaling factor as
195 : * (@src height) / (@dst height).
196 : *
197 : * If the scale is below 1 << 16, round down. If the scale is above
198 : * 1 << 16, round up. This will calculate the scale with the most
199 : * pessimistic limit calculation.
200 : *
201 : * RETURNS:
202 : * The vertical scaling factor, or errno of out of limits.
203 : */
204 17 : int drm_rect_calc_vscale(const struct drm_rect *src,
205 : const struct drm_rect *dst,
206 : int min_vscale, int max_vscale)
207 : {
208 34 : int src_h = drm_rect_height(src);
209 34 : int dst_h = drm_rect_height(dst);
210 17 : int vscale = drm_calc_scale(src_h, dst_h);
211 :
212 17 : if (vscale < 0 || dst_h == 0)
213 : return vscale;
214 :
215 15 : if (vscale < min_vscale || vscale > max_vscale)
216 : return -ERANGE;
217 :
218 11 : return vscale;
219 : }
220 : EXPORT_SYMBOL(drm_rect_calc_vscale);
221 :
222 : /**
223 : * drm_rect_debug_print - print the rectangle information
224 : * @prefix: prefix string
225 : * @r: rectangle to print
226 : * @fixed_point: rectangle is in 16.16 fixed point format
227 : */
228 6 : void drm_rect_debug_print(const char *prefix, const struct drm_rect *r, bool fixed_point)
229 : {
230 6 : if (fixed_point)
231 6 : DRM_DEBUG_KMS("%s" DRM_RECT_FP_FMT "\n", prefix, DRM_RECT_FP_ARG(r));
232 : else
233 12 : DRM_DEBUG_KMS("%s" DRM_RECT_FMT "\n", prefix, DRM_RECT_ARG(r));
234 6 : }
235 : EXPORT_SYMBOL(drm_rect_debug_print);
236 :
237 : /**
238 : * drm_rect_rotate - Rotate the rectangle
239 : * @r: rectangle to be rotated
240 : * @width: Width of the coordinate space
241 : * @height: Height of the coordinate space
242 : * @rotation: Transformation to be applied
243 : *
244 : * Apply @rotation to the coordinates of rectangle @r.
245 : *
246 : * @width and @height combined with @rotation define
247 : * the location of the new origin.
248 : *
249 : * @width correcsponds to the horizontal and @height
250 : * to the vertical axis of the untransformed coordinate
251 : * space.
252 : */
253 18 : void drm_rect_rotate(struct drm_rect *r,
254 : int width, int height,
255 : unsigned int rotation)
256 : {
257 : struct drm_rect tmp;
258 :
259 18 : if (rotation & (DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y)) {
260 3 : tmp = *r;
261 :
262 3 : if (rotation & DRM_MODE_REFLECT_X) {
263 2 : r->x1 = width - tmp.x2;
264 2 : r->x2 = width - tmp.x1;
265 : }
266 :
267 3 : if (rotation & DRM_MODE_REFLECT_Y) {
268 1 : r->y1 = height - tmp.y2;
269 1 : r->y2 = height - tmp.y1;
270 : }
271 : }
272 :
273 18 : switch (rotation & DRM_MODE_ROTATE_MASK) {
274 : case DRM_MODE_ROTATE_0:
275 : break;
276 : case DRM_MODE_ROTATE_90:
277 2 : tmp = *r;
278 2 : r->x1 = tmp.y1;
279 2 : r->x2 = tmp.y2;
280 2 : r->y1 = width - tmp.x2;
281 2 : r->y2 = width - tmp.x1;
282 2 : break;
283 : case DRM_MODE_ROTATE_180:
284 1 : tmp = *r;
285 1 : r->x1 = width - tmp.x2;
286 1 : r->x2 = width - tmp.x1;
287 1 : r->y1 = height - tmp.y2;
288 1 : r->y2 = height - tmp.y1;
289 1 : break;
290 : case DRM_MODE_ROTATE_270:
291 1 : tmp = *r;
292 1 : r->x1 = height - tmp.y2;
293 1 : r->x2 = height - tmp.y1;
294 1 : r->y1 = tmp.x1;
295 1 : r->y2 = tmp.x2;
296 1 : break;
297 : default:
298 : break;
299 : }
300 18 : }
301 : EXPORT_SYMBOL(drm_rect_rotate);
302 :
303 : /**
304 : * drm_rect_rotate_inv - Inverse rotate the rectangle
305 : * @r: rectangle to be rotated
306 : * @width: Width of the coordinate space
307 : * @height: Height of the coordinate space
308 : * @rotation: Transformation whose inverse is to be applied
309 : *
310 : * Apply the inverse of @rotation to the coordinates
311 : * of rectangle @r.
312 : *
313 : * @width and @height combined with @rotation define
314 : * the location of the new origin.
315 : *
316 : * @width correcsponds to the horizontal and @height
317 : * to the vertical axis of the original untransformed
318 : * coordinate space, so that you never have to flip
319 : * them when doing a rotatation and its inverse.
320 : * That is, if you do ::
321 : *
322 : * drm_rect_rotate(&r, width, height, rotation);
323 : * drm_rect_rotate_inv(&r, width, height, rotation);
324 : *
325 : * you will always get back the original rectangle.
326 : */
327 16 : void drm_rect_rotate_inv(struct drm_rect *r,
328 : int width, int height,
329 : unsigned int rotation)
330 : {
331 : struct drm_rect tmp;
332 :
333 16 : switch (rotation & DRM_MODE_ROTATE_MASK) {
334 : case DRM_MODE_ROTATE_0:
335 : break;
336 : case DRM_MODE_ROTATE_90:
337 2 : tmp = *r;
338 2 : r->x1 = width - tmp.y2;
339 2 : r->x2 = width - tmp.y1;
340 2 : r->y1 = tmp.x1;
341 2 : r->y2 = tmp.x2;
342 2 : break;
343 : case DRM_MODE_ROTATE_180:
344 1 : tmp = *r;
345 1 : r->x1 = width - tmp.x2;
346 1 : r->x2 = width - tmp.x1;
347 1 : r->y1 = height - tmp.y2;
348 1 : r->y2 = height - tmp.y1;
349 1 : break;
350 : case DRM_MODE_ROTATE_270:
351 1 : tmp = *r;
352 1 : r->x1 = tmp.y1;
353 1 : r->x2 = tmp.y2;
354 1 : r->y1 = height - tmp.x2;
355 1 : r->y2 = height - tmp.x1;
356 1 : break;
357 : default:
358 : break;
359 : }
360 :
361 16 : if (rotation & (DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y)) {
362 3 : tmp = *r;
363 :
364 3 : if (rotation & DRM_MODE_REFLECT_X) {
365 2 : r->x1 = width - tmp.x2;
366 2 : r->x2 = width - tmp.x1;
367 : }
368 :
369 3 : if (rotation & DRM_MODE_REFLECT_Y) {
370 1 : r->y1 = height - tmp.y2;
371 1 : r->y2 = height - tmp.y1;
372 : }
373 : }
374 16 : }
375 : EXPORT_SYMBOL(drm_rect_rotate_inv);
|
