1/* 2* Copyright (c) 2015, 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 34#define __CLASS__ "RectUtils" 35 36namespace sdm { 37 38bool IsValid(const LayerRect &rect) { 39 return ((rect.bottom > rect.top) && (rect.right > rect.left)); 40} 41 42bool IsCongruent(const LayerRect &rect1, const LayerRect &rect2) { 43 return ((rect1.left == rect2.left) && 44 (rect1.top == rect2.top) && 45 (rect1.right == rect2.right) && 46 (rect1.bottom == rect2.bottom)); 47} 48 49void Log(DebugTag debug_tag, const char *prefix, const LayerRect &roi) { 50 DLOGV_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f", 51 prefix, roi.left, roi.top, roi.right, roi.bottom); 52} 53 54void Normalize(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect) { 55 rect->left = ROUND_UP_ALIGN_UP(rect->left, align_x); 56 rect->right = ROUND_UP_ALIGN_DOWN(rect->right, align_x); 57 rect->top = ROUND_UP_ALIGN_UP(rect->top, align_y); 58 rect->bottom = ROUND_UP_ALIGN_DOWN(rect->bottom, align_y); 59} 60 61LayerRect Intersection(const LayerRect &rect1, const LayerRect &rect2) { 62 LayerRect res; 63 64 if (!IsValid(rect1) || !IsValid(rect2)) { 65 return LayerRect(); 66 } 67 68 res.left = MAX(rect1.left, rect2.left); 69 res.top = MAX(rect1.top, rect2.top); 70 res.right = MIN(rect1.right, rect2.right); 71 res.bottom = MIN(rect1.bottom, rect2.bottom); 72 73 if (!IsValid(res)) { 74 return LayerRect(); 75 } 76 77 return res; 78} 79 80LayerRect Reposition(const LayerRect &rect, const int &x_offset, const int &y_offset) { 81 LayerRect res; 82 83 if (!IsValid(rect)) { 84 return LayerRect(); 85 } 86 87 res.left = rect.left + FLOAT(x_offset); 88 res.top = rect.top + FLOAT(y_offset); 89 res.right = rect.right + FLOAT(x_offset); 90 res.bottom = rect.bottom + FLOAT(y_offset); 91 92 return res; 93} 94 95// Not a geometrical rect deduction. Deducts rect2 from rect1 only if it results a single rect 96LayerRect Subtract(const LayerRect &rect1, const LayerRect &rect2) { 97 LayerRect res; 98 99 res = rect1; 100 101 if ((rect1.left == rect2.left) && (rect1.right == rect2.right)) { 102 if ((rect1.top == rect2.top) && (rect2.bottom <= rect1.bottom)) { 103 res.top = rect2.bottom; 104 } else if ((rect1.bottom == rect2.bottom) && (rect2.top >= rect1.top)) { 105 res.bottom = rect2.top; 106 } 107 } else if ((rect1.top == rect2.top) && (rect1.bottom == rect2.bottom)) { 108 if ((rect1.left == rect2.left) && (rect2.right <= rect1.right)) { 109 res.left = rect2.right; 110 } else if ((rect1.right == rect2.right) && (rect2.left >= rect1.left)) { 111 res.right = rect2.left; 112 } 113 } 114 115 return res; 116} 117 118LayerRect Union(const LayerRect &rect1, const LayerRect &rect2) { 119 LayerRect res; 120 121 if (!IsValid(rect1) && !IsValid(rect2)) { 122 return LayerRect(); 123 } 124 125 if (!IsValid(rect1)) { 126 return rect2; 127 } 128 129 if (!IsValid(rect2)) { 130 return rect1; 131 } 132 133 res.left = MIN(rect1.left, rect2.left); 134 res.top = MIN(rect1.top, rect2.top); 135 res.right = MAX(rect1.right, rect2.right); 136 res.bottom = MAX(rect1.bottom, rect2.bottom); 137 138 return res; 139} 140 141void SplitLeftRight(const LayerRect &in_rect, uint32_t split_count, uint32_t align_x, 142 bool flip_horizontal, LayerRect *out_rects) { 143 LayerRect rect_temp = in_rect; 144 145 uint32_t split_width = UINT32(rect_temp.right - rect_temp.left) / split_count; 146 float aligned_width = FLOAT(CeilToMultipleOf(split_width, align_x)); 147 148 for (uint32_t count = 0; count < split_count; count++) { 149 float aligned_right = rect_temp.left + aligned_width; 150 out_rects[count].left = rect_temp.left; 151 out_rects[count].right = MIN(rect_temp.right, aligned_right); 152 out_rects[count].top = rect_temp.top; 153 out_rects[count].bottom = rect_temp.bottom; 154 155 rect_temp.left = out_rects[count].right; 156 157 Log(kTagRotator, "SplitLeftRight", out_rects[count]); 158 } 159 160 // If we have a horizontal flip, then we should be splitting the source from right to left 161 // to ensure that the right split will have an aligned width that matches the alignment on the 162 // destination. 163 if (flip_horizontal && split_count > 1) { 164 out_rects[0].right = out_rects[0].left + (out_rects[1].right - out_rects[1].left); 165 out_rects[1].left = out_rects[0].right; 166 Log(kTagRotator, "Adjusted Left", out_rects[0]); 167 Log(kTagRotator, "Adjusted Right", out_rects[1]); 168 } 169} 170 171void SplitTopBottom(const LayerRect &in_rect, uint32_t split_count, uint32_t align_y, 172 bool flip_horizontal, LayerRect *out_rects) { 173 LayerRect rect_temp = in_rect; 174 175 uint32_t split_height = UINT32(rect_temp.bottom - rect_temp.top) / split_count; 176 float aligned_height = FLOAT(CeilToMultipleOf(split_height, align_y)); 177 178 for (uint32_t count = 0; count < split_count; count++) { 179 float aligned_bottom = rect_temp.top + aligned_height; 180 out_rects[count].top = rect_temp.top; 181 out_rects[count].bottom = MIN(rect_temp.bottom, aligned_bottom); 182 out_rects[count].left = rect_temp.left; 183 out_rects[count].right = rect_temp.right; 184 185 rect_temp.top = out_rects[count].bottom; 186 187 Log(kTagRotator, "SplitTopBottom", out_rects[count]); 188 } 189 190 // If we have a horizontal flip, then we should be splitting the destination from bottom to top 191 // to ensure that the bottom split's y-offset is aligned correctly after we swap the destinations 192 // while accounting for the flip. 193 if (flip_horizontal && split_count > 1) { 194 out_rects[0].bottom = out_rects[0].top + (out_rects[1].bottom - out_rects[1].top); 195 out_rects[1].top = out_rects[0].bottom; 196 Log(kTagRotator, "Adjusted Top", out_rects[0]); 197 Log(kTagRotator, "Adjusted Bottom", out_rects[1]); 198 } 199} 200 201} // namespace sdm 202 203