2 * Copyright (C) 2011-2013 Intel Corporation
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:
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
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
24 #include <linux/errno.h>
25 #include <linux/export.h>
26 #include <linux/kernel.h>
28 #include <drm/drm_rect.h>
31 * drm_rect_intersect - intersect two rectangles
32 * @r1: first rectangle
33 * @r2: second rectangle
35 * Calculate the intersection of rectangles @r1 and @r2.
36 * @r1 will be overwritten with the intersection.
39 * %true if rectangle @r1 is still visible after the operation,
42 bool drm_rect_intersect(struct drm_rect *r1, const struct drm_rect *r2)
44 r1->x1 = max(r1->x1, r2->x1);
45 r1->y1 = max(r1->y1, r2->y1);
46 r1->x2 = min(r1->x2, r2->x2);
47 r1->y2 = min(r1->y2, r2->y2);
49 return drm_rect_visible(r1);
51 EXPORT_SYMBOL(drm_rect_intersect);
53 static u32 clip_scaled(u32 src, u32 dst, u32 clip)
55 u64 tmp = mul_u32_u32(src, dst - clip);
58 * Round toward 1.0 when clipping so that we don't accidentally
59 * change upscaling to downscaling or vice versa.
61 if (src < (dst << 16))
62 return DIV_ROUND_UP_ULL(tmp, dst);
64 return DIV_ROUND_DOWN_ULL(tmp, dst);
68 * drm_rect_clip_scaled - perform a scaled clip operation
69 * @src: source window rectangle
70 * @dst: destination window rectangle
71 * @clip: clip rectangle
73 * Clip rectangle @dst by rectangle @clip. Clip rectangle @src by the
74 * same amounts multiplied by @hscale and @vscale.
77 * %true if rectangle @dst is still visible after being clipped,
80 bool drm_rect_clip_scaled(struct drm_rect *src, struct drm_rect *dst,
81 const struct drm_rect *clip)
85 diff = clip->x1 - dst->x1;
87 u32 new_src_w = clip_scaled(drm_rect_width(src),
88 drm_rect_width(dst), diff);
90 src->x1 = clamp_t(int64_t, src->x2 - new_src_w, INT_MIN, INT_MAX);
93 diff = clip->y1 - dst->y1;
95 u32 new_src_h = clip_scaled(drm_rect_height(src),
96 drm_rect_height(dst), diff);
98 src->y1 = clamp_t(int64_t, src->y2 - new_src_h, INT_MIN, INT_MAX);
101 diff = dst->x2 - clip->x2;
103 u32 new_src_w = clip_scaled(drm_rect_width(src),
104 drm_rect_width(dst), diff);
106 src->x2 = clamp_t(int64_t, src->x1 + new_src_w, INT_MIN, INT_MAX);
109 diff = dst->y2 - clip->y2;
111 u32 new_src_h = clip_scaled(drm_rect_height(src),
112 drm_rect_height(dst), diff);
114 src->y2 = clamp_t(int64_t, src->y1 + new_src_h, INT_MIN, INT_MAX);
118 return drm_rect_visible(dst);
120 EXPORT_SYMBOL(drm_rect_clip_scaled);
122 static int drm_calc_scale(int src, int dst)
126 if (WARN_ON(src < 0 || dst < 0))
132 if (src > (dst << 16))
133 return DIV_ROUND_UP(src, dst);
141 * drm_rect_calc_hscale - calculate the horizontal scaling factor
142 * @src: source window rectangle
143 * @dst: destination window rectangle
144 * @min_hscale: minimum allowed horizontal scaling factor
145 * @max_hscale: maximum allowed horizontal scaling factor
147 * Calculate the horizontal scaling factor as
148 * (@src width) / (@dst width).
150 * If the scale is below 1 << 16, round down. If the scale is above
151 * 1 << 16, round up. This will calculate the scale with the most
152 * pessimistic limit calculation.
155 * The horizontal scaling factor, or errno of out of limits.
157 int drm_rect_calc_hscale(const struct drm_rect *src,
158 const struct drm_rect *dst,
159 int min_hscale, int max_hscale)
161 int src_w = drm_rect_width(src);
162 int dst_w = drm_rect_width(dst);
163 int hscale = drm_calc_scale(src_w, dst_w);
165 if (hscale < 0 || dst_w == 0)
168 if (hscale < min_hscale || hscale > max_hscale)
173 EXPORT_SYMBOL(drm_rect_calc_hscale);
176 * drm_rect_calc_vscale - calculate the vertical scaling factor
177 * @src: source window rectangle
178 * @dst: destination window rectangle
179 * @min_vscale: minimum allowed vertical scaling factor
180 * @max_vscale: maximum allowed vertical scaling factor
182 * Calculate the vertical scaling factor as
183 * (@src height) / (@dst height).
185 * If the scale is below 1 << 16, round down. If the scale is above
186 * 1 << 16, round up. This will calculate the scale with the most
187 * pessimistic limit calculation.
190 * The vertical scaling factor, or errno of out of limits.
192 int drm_rect_calc_vscale(const struct drm_rect *src,
193 const struct drm_rect *dst,
194 int min_vscale, int max_vscale)
196 int src_h = drm_rect_height(src);
197 int dst_h = drm_rect_height(dst);
198 int vscale = drm_calc_scale(src_h, dst_h);
200 if (vscale < 0 || dst_h == 0)
203 if (vscale < min_vscale || vscale > max_vscale)
208 EXPORT_SYMBOL(drm_rect_calc_vscale);
211 * drm_rect_debug_print - print the rectangle information
212 * @prefix: prefix string
213 * @r: rectangle to print
214 * @fixed_point: rectangle is in 16.16 fixed point format
216 void drm_rect_debug_print(const char *prefix, const struct drm_rect *r, bool fixed_point)
219 DRM_DEBUG_KMS("%s" DRM_RECT_FP_FMT "\n", prefix, DRM_RECT_FP_ARG(r));
221 DRM_DEBUG_KMS("%s" DRM_RECT_FMT "\n", prefix, DRM_RECT_ARG(r));
223 EXPORT_SYMBOL(drm_rect_debug_print);
226 * drm_rect_rotate - Rotate the rectangle
227 * @r: rectangle to be rotated
228 * @width: Width of the coordinate space
229 * @height: Height of the coordinate space
230 * @rotation: Transformation to be applied
232 * Apply @rotation to the coordinates of rectangle @r.
234 * @width and @height combined with @rotation define
235 * the location of the new origin.
237 * @width correcsponds to the horizontal and @height
238 * to the vertical axis of the untransformed coordinate
241 void drm_rect_rotate(struct drm_rect *r,
242 int width, int height,
243 unsigned int rotation)
247 if (rotation & (DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y)) {
250 if (rotation & DRM_MODE_REFLECT_X) {
251 r->x1 = width - tmp.x2;
252 r->x2 = width - tmp.x1;
255 if (rotation & DRM_MODE_REFLECT_Y) {
256 r->y1 = height - tmp.y2;
257 r->y2 = height - tmp.y1;
261 switch (rotation & DRM_MODE_ROTATE_MASK) {
262 case DRM_MODE_ROTATE_0:
264 case DRM_MODE_ROTATE_90:
268 r->y1 = width - tmp.x2;
269 r->y2 = width - tmp.x1;
271 case DRM_MODE_ROTATE_180:
273 r->x1 = width - tmp.x2;
274 r->x2 = width - tmp.x1;
275 r->y1 = height - tmp.y2;
276 r->y2 = height - tmp.y1;
278 case DRM_MODE_ROTATE_270:
280 r->x1 = height - tmp.y2;
281 r->x2 = height - tmp.y1;
289 EXPORT_SYMBOL(drm_rect_rotate);
292 * drm_rect_rotate_inv - Inverse rotate the rectangle
293 * @r: rectangle to be rotated
294 * @width: Width of the coordinate space
295 * @height: Height of the coordinate space
296 * @rotation: Transformation whose inverse is to be applied
298 * Apply the inverse of @rotation to the coordinates
301 * @width and @height combined with @rotation define
302 * the location of the new origin.
304 * @width correcsponds to the horizontal and @height
305 * to the vertical axis of the original untransformed
306 * coordinate space, so that you never have to flip
307 * them when doing a rotatation and its inverse.
308 * That is, if you do ::
310 * drm_rect_rotate(&r, width, height, rotation);
311 * drm_rect_rotate_inv(&r, width, height, rotation);
313 * you will always get back the original rectangle.
315 void drm_rect_rotate_inv(struct drm_rect *r,
316 int width, int height,
317 unsigned int rotation)
321 switch (rotation & DRM_MODE_ROTATE_MASK) {
322 case DRM_MODE_ROTATE_0:
324 case DRM_MODE_ROTATE_90:
326 r->x1 = width - tmp.y2;
327 r->x2 = width - tmp.y1;
331 case DRM_MODE_ROTATE_180:
333 r->x1 = width - tmp.x2;
334 r->x2 = width - tmp.x1;
335 r->y1 = height - tmp.y2;
336 r->y2 = height - tmp.y1;
338 case DRM_MODE_ROTATE_270:
342 r->y1 = height - tmp.x2;
343 r->y2 = height - tmp.x1;
349 if (rotation & (DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y)) {
352 if (rotation & DRM_MODE_REFLECT_X) {
353 r->x1 = width - tmp.x2;
354 r->x2 = width - tmp.x1;
357 if (rotation & DRM_MODE_REFLECT_Y) {
358 r->y1 = height - tmp.y2;
359 r->y2 = height - tmp.y1;
363 EXPORT_SYMBOL(drm_rect_rotate_inv);