1/*
2* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved.
3*
4* Redistribution and use in source and binary forms, with or without
5* modification, are permitted provided that the following conditions are
6* met:
7*   * Redistributions of source code must retain the above copyright
8*     notice, this list of conditions and the following disclaimer.
9*   * Redistributions in binary form must reproduce the above
10*     copyright notice, this list of conditions and the following
11*     disclaimer in the documentation and/or other materials provided
12*     with the distribution.
13*   * Neither the name of The Linux Foundation nor the names of its
14*     contributors may be used to endorse or promote products derived
15*     from this software without specific prior written permission.
16*
17* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28*/
29
30#include <math.h>
31#include <utils/rect.h>
32#include <utils/constants.h>
33#include <algorithm>
34
35#define __CLASS__ "RectUtils"
36
37namespace sdm {
38
39bool IsValid(const LayerRect &rect) {
40  return ((rect.bottom > rect.top) && (rect.right > rect.left));
41}
42
43bool IsCongruent(const LayerRect &rect1, const LayerRect &rect2) {
44  return ((rect1.left == rect2.left) &&
45          (rect1.top == rect2.top) &&
46          (rect1.right == rect2.right) &&
47          (rect1.bottom == rect2.bottom));
48}
49
50void LogI(DebugTag debug_tag, const char *prefix, const LayerRect &roi) {
51  DLOGI_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f",
52           prefix, roi.left, roi.top, roi.right, roi.bottom);
53}
54
55void Log(DebugTag debug_tag, const char *prefix, const LayerRect &roi) {
56  DLOGV_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f",
57           prefix, roi.left, roi.top, roi.right, roi.bottom);
58}
59
60void Normalize(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect) {
61    rect->left = ROUND_UP_ALIGN_UP(rect->left, align_x);
62    rect->right = ROUND_UP_ALIGN_DOWN(rect->right, align_x);
63    rect->top = ROUND_UP_ALIGN_UP(rect->top, align_y);
64    rect->bottom = ROUND_UP_ALIGN_DOWN(rect->bottom, align_y);
65}
66
67LayerRect Intersection(const LayerRect &rect1, const LayerRect &rect2) {
68  LayerRect res;
69
70  if (!IsValid(rect1) || !IsValid(rect2)) {
71    return LayerRect();
72  }
73
74  res.left = std::max(rect1.left, rect2.left);
75  res.top = std::max(rect1.top, rect2.top);
76  res.right = std::min(rect1.right, rect2.right);
77  res.bottom = std::min(rect1.bottom, rect2.bottom);
78
79  if (!IsValid(res)) {
80    return LayerRect();
81  }
82
83  return res;
84}
85
86LayerRect Reposition(const LayerRect &rect, const int &x_offset, const int &y_offset) {
87  LayerRect res;
88
89  if (!IsValid(rect)) {
90    return LayerRect();
91  }
92
93  res.left = rect.left + FLOAT(x_offset);
94  res.top = rect.top + FLOAT(y_offset);
95  res.right = rect.right + FLOAT(x_offset);
96  res.bottom = rect.bottom + FLOAT(y_offset);
97
98  return res;
99}
100
101// Not a geometrical rect deduction. Deducts rect2 from rect1 only if it results a single rect
102LayerRect Subtract(const LayerRect &rect1, const LayerRect &rect2) {
103  LayerRect res;
104
105  res = rect1;
106
107  if ((rect1.left == rect2.left) && (rect1.right == rect2.right)) {
108    if ((rect1.top == rect2.top) && (rect2.bottom <= rect1.bottom)) {
109      res.top = rect2.bottom;
110    } else if ((rect1.bottom == rect2.bottom) && (rect2.top >= rect1.top)) {
111      res.bottom = rect2.top;
112    }
113  } else if ((rect1.top == rect2.top) && (rect1.bottom == rect2.bottom)) {
114    if ((rect1.left == rect2.left) && (rect2.right <= rect1.right)) {
115      res.left = rect2.right;
116    } else if ((rect1.right == rect2.right) && (rect2.left >= rect1.left)) {
117      res.right = rect2.left;
118    }
119  }
120
121  return res;
122}
123
124LayerRect Union(const LayerRect &rect1, const LayerRect &rect2) {
125  LayerRect res;
126
127  if (!IsValid(rect1) && !IsValid(rect2)) {
128    return LayerRect();
129  }
130
131  if (!IsValid(rect1)) {
132    return rect2;
133  }
134
135  if (!IsValid(rect2)) {
136    return rect1;
137  }
138
139  res.left = std::min(rect1.left, rect2.left);
140  res.top = std::min(rect1.top, rect2.top);
141  res.right = std::max(rect1.right, rect2.right);
142  res.bottom = std::max(rect1.bottom, rect2.bottom);
143
144  return res;
145}
146
147void SplitLeftRight(const LayerRect &in_rect, uint32_t split_count, uint32_t align_x,
148                    bool flip_horizontal, LayerRect *out_rects) {
149  LayerRect rect_temp = in_rect;
150
151  uint32_t split_width = UINT32(rect_temp.right - rect_temp.left) / split_count;
152  float aligned_width = FLOAT(CeilToMultipleOf(split_width, align_x));
153
154  for (uint32_t count = 0; count < split_count; count++) {
155    float aligned_right = rect_temp.left + aligned_width;
156    out_rects[count].left = rect_temp.left;
157    out_rects[count].right = std::min(rect_temp.right, aligned_right);
158    out_rects[count].top = rect_temp.top;
159    out_rects[count].bottom = rect_temp.bottom;
160
161    rect_temp.left = out_rects[count].right;
162
163    Log(kTagRotator, "SplitLeftRight", out_rects[count]);
164  }
165
166  // If we have a horizontal flip, then we should be splitting the source from right to left
167  // to ensure that the right split will have an aligned width that matches the alignment on the
168  // destination.
169  if (flip_horizontal && split_count > 1) {
170    out_rects[0].right = out_rects[0].left + (out_rects[1].right - out_rects[1].left);
171    out_rects[1].left = out_rects[0].right;
172    Log(kTagRotator, "Adjusted Left", out_rects[0]);
173    Log(kTagRotator, "Adjusted Right", out_rects[1]);
174  }
175}
176
177void SplitTopBottom(const LayerRect &in_rect, uint32_t split_count, uint32_t align_y,
178                    bool flip_horizontal, LayerRect *out_rects) {
179  LayerRect rect_temp = in_rect;
180
181  uint32_t split_height = UINT32(rect_temp.bottom - rect_temp.top) / split_count;
182  float aligned_height = FLOAT(CeilToMultipleOf(split_height, align_y));
183
184  for (uint32_t count = 0; count < split_count; count++) {
185    float aligned_bottom = rect_temp.top + aligned_height;
186    out_rects[count].top = rect_temp.top;
187    out_rects[count].bottom = std::min(rect_temp.bottom, aligned_bottom);
188    out_rects[count].left = rect_temp.left;
189    out_rects[count].right = rect_temp.right;
190
191    rect_temp.top = out_rects[count].bottom;
192
193    Log(kTagRotator, "SplitTopBottom", out_rects[count]);
194  }
195
196  // If we have a horizontal flip, then we should be splitting the destination from bottom to top
197  // to ensure that the bottom split's y-offset is aligned correctly after we swap the destinations
198  // while accounting for the flip.
199  if (flip_horizontal && split_count > 1) {
200    out_rects[0].bottom = out_rects[0].top + (out_rects[1].bottom - out_rects[1].top);
201    out_rects[1].top = out_rects[0].bottom;
202    Log(kTagRotator, "Adjusted Top", out_rects[0]);
203    Log(kTagRotator, "Adjusted Bottom", out_rects[1]);
204  }
205}
206
207void MapRect(const LayerRect &src_domain, const LayerRect &dst_domain, const LayerRect &in_rect,
208             LayerRect *out_rect) {
209  if (!IsValid(src_domain) || !IsValid(dst_domain) || !IsValid(in_rect)) {
210    return;
211  }
212
213  int x_offset = INT(src_domain.left);
214  int y_offset = INT(src_domain.top);
215
216  LayerRect modified_in_rect = Reposition(in_rect, -x_offset, -y_offset);
217  float src_domain_width = src_domain.right - src_domain.left;
218  float src_domain_height = src_domain.bottom - src_domain.top;
219  float dst_domain_width = dst_domain.right - dst_domain.left;
220  float dst_domain_height = dst_domain.bottom - dst_domain.top;
221
222  float width_ratio = dst_domain_width / src_domain_width;
223  float height_ratio = dst_domain_height / src_domain_height;
224
225  out_rect->left = dst_domain.left + (width_ratio * modified_in_rect.left);
226  out_rect->top = dst_domain.top + (height_ratio * modified_in_rect.top);
227  out_rect->right = dst_domain.left + (width_ratio * modified_in_rect.right);
228  out_rect->bottom = dst_domain.top + (height_ratio * modified_in_rect.bottom);
229}
230
231void TransformHV(const LayerRect &src_domain, const LayerRect &in_rect,
232                 const LayerTransform &transform, LayerRect *out_rect) {
233  if (!IsValid(src_domain) || !IsValid(in_rect)) {
234    return;
235  }
236
237  float in_width = in_rect.right - in_rect.left;
238  float in_height = in_rect.bottom - in_rect.top;
239  float x_offset = in_rect.left - src_domain.left;
240  float y_offset = in_rect.top - src_domain.top;
241  *out_rect = in_rect;
242
243  if (transform.flip_horizontal) {
244    out_rect->right = src_domain.right - x_offset;
245    out_rect->left = out_rect->right - in_width;
246  }
247
248  if (transform.flip_vertical) {
249    out_rect->bottom = src_domain.bottom - y_offset;
250    out_rect->top = out_rect->bottom - in_height;
251  }
252}
253
254RectOrientation GetOrientation(const LayerRect &in_rect) {
255  if (!IsValid(in_rect)) {
256    return kOrientationUnknown;
257  }
258
259  float input_width = in_rect.right - in_rect.left;
260  float input_height = in_rect.bottom - in_rect.top;
261
262  if (input_width < input_height) {
263    return kOrientationPortrait;
264  }
265
266  return kOrientationLandscape;
267}
268
269}  // namespace sdm
270
271