You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
354 lines
12 KiB
354 lines
12 KiB
/*
|
|
* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <utils/rect.h>
|
|
#include <utils/constants.h>
|
|
#include <algorithm>
|
|
|
|
#define __CLASS__ "RectUtils"
|
|
|
|
namespace sdm {
|
|
|
|
bool IsValid(const LayerRect &rect) {
|
|
return ((rect.bottom > rect.top) && (rect.right > rect.left));
|
|
}
|
|
|
|
bool IsCongruent(const LayerRect &rect1, const LayerRect &rect2) {
|
|
return ((rect1.left == rect2.left) &&
|
|
(rect1.top == rect2.top) &&
|
|
(rect1.right == rect2.right) &&
|
|
(rect1.bottom == rect2.bottom));
|
|
}
|
|
|
|
void LogI(DebugTag debug_tag, const char *prefix, const LayerRect &roi) {
|
|
DLOGI_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f",
|
|
prefix, roi.left, roi.top, roi.right, roi.bottom);
|
|
}
|
|
|
|
void Log(DebugTag debug_tag, const char *prefix, const LayerRect &roi) {
|
|
DLOGV_IF(debug_tag, "%s: left = %.0f, top = %.0f, right = %.0f, bottom = %.0f",
|
|
prefix, roi.left, roi.top, roi.right, roi.bottom);
|
|
}
|
|
|
|
void Normalize(const uint32_t &align_x, const uint32_t &align_y, LayerRect *rect) {
|
|
rect->left = ROUND_UP_ALIGN_UP(rect->left, align_x);
|
|
rect->right = ROUND_UP_ALIGN_DOWN(rect->right, align_x);
|
|
rect->top = ROUND_UP_ALIGN_UP(rect->top, align_y);
|
|
rect->bottom = ROUND_UP_ALIGN_DOWN(rect->bottom, align_y);
|
|
}
|
|
|
|
LayerRect Intersection(const LayerRect &rect1, const LayerRect &rect2) {
|
|
LayerRect res;
|
|
|
|
if (!IsValid(rect1) || !IsValid(rect2)) {
|
|
return LayerRect();
|
|
}
|
|
|
|
res.left = std::max(rect1.left, rect2.left);
|
|
res.top = std::max(rect1.top, rect2.top);
|
|
res.right = std::min(rect1.right, rect2.right);
|
|
res.bottom = std::min(rect1.bottom, rect2.bottom);
|
|
|
|
if (!IsValid(res)) {
|
|
return LayerRect();
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
LayerRect Reposition(const LayerRect &rect, const int &x_offset, const int &y_offset) {
|
|
LayerRect res;
|
|
|
|
if (!IsValid(rect)) {
|
|
return LayerRect();
|
|
}
|
|
|
|
res.left = rect.left + FLOAT(x_offset);
|
|
res.top = rect.top + FLOAT(y_offset);
|
|
res.right = rect.right + FLOAT(x_offset);
|
|
res.bottom = rect.bottom + FLOAT(y_offset);
|
|
|
|
return res;
|
|
}
|
|
|
|
// Is rect2 completely inside rect1?
|
|
bool Contains(const LayerRect &rect1, const LayerRect &rect2) {
|
|
if (!IsValid(rect1) || !IsValid(rect2)) {
|
|
return false;
|
|
}
|
|
return (rect1.top <= rect2.top && rect1.bottom >= rect2.bottom &&
|
|
rect1.left <= rect2.left && rect1.right >= rect2.right);
|
|
}
|
|
|
|
// subtracts 2 rects iff result of subtraction is 2 rects.
|
|
void Subtract(const LayerRect &rect1, const LayerRect &rect2, LayerRect *res) {
|
|
if (!res) {
|
|
return;
|
|
}
|
|
if (!IsValid(rect1) || !IsValid(rect2)) {
|
|
return;
|
|
}
|
|
|
|
if (rect1.left != rect2.left || rect1.right != rect2.right) {
|
|
return;
|
|
}
|
|
res[0].left = rect1.left;
|
|
res[0].right = rect1.right;
|
|
if (rect1.top < rect2.top) {
|
|
res[0].top = rect1.top;
|
|
res[0].bottom = rect2.top;
|
|
} else {
|
|
res[0].top = rect2.top;
|
|
res[0].bottom = rect1.top;
|
|
}
|
|
res[1].left = rect1.left;
|
|
res[1].right = rect1.right;
|
|
if (rect1.bottom < rect2.bottom) {
|
|
res[1].top = rect1.bottom;
|
|
res[1].bottom = rect2.bottom;
|
|
} else {
|
|
res[1].top = rect2.bottom;
|
|
res[1].bottom = rect1.bottom;
|
|
}
|
|
}
|
|
|
|
// Not a geometrical rect deduction. Deducts rect2 from rect1 only if it results a single rect
|
|
LayerRect Subtract(const LayerRect &rect1, const LayerRect &rect2) {
|
|
LayerRect res;
|
|
|
|
res = rect1;
|
|
|
|
if ((rect1.left == rect2.left) && (rect1.right == rect2.right)) {
|
|
if ((rect1.top == rect2.top) && (rect2.bottom <= rect1.bottom)) {
|
|
res.top = rect2.bottom;
|
|
} else if ((rect1.bottom == rect2.bottom) && (rect2.top >= rect1.top)) {
|
|
res.bottom = rect2.top;
|
|
}
|
|
} else if ((rect1.top == rect2.top) && (rect1.bottom == rect2.bottom)) {
|
|
if ((rect1.left == rect2.left) && (rect2.right <= rect1.right)) {
|
|
res.left = rect2.right;
|
|
} else if ((rect1.right == rect2.right) && (rect2.left >= rect1.left)) {
|
|
res.right = rect2.left;
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
LayerRect Union(const LayerRect &rect1, const LayerRect &rect2) {
|
|
LayerRect res;
|
|
|
|
if (!IsValid(rect1) && !IsValid(rect2)) {
|
|
return LayerRect();
|
|
}
|
|
|
|
if (!IsValid(rect1)) {
|
|
return rect2;
|
|
}
|
|
|
|
if (!IsValid(rect2)) {
|
|
return rect1;
|
|
}
|
|
|
|
res.left = std::min(rect1.left, rect2.left);
|
|
res.top = std::min(rect1.top, rect2.top);
|
|
res.right = std::max(rect1.right, rect2.right);
|
|
res.bottom = std::max(rect1.bottom, rect2.bottom);
|
|
|
|
return res;
|
|
}
|
|
|
|
void SplitLeftRight(const LayerRect &in_rect, uint32_t split_count, uint32_t align_x,
|
|
bool flip_horizontal, LayerRect *out_rects) {
|
|
LayerRect rect_temp = in_rect;
|
|
|
|
uint32_t split_width = UINT32(rect_temp.right - rect_temp.left) / split_count;
|
|
float aligned_width = FLOAT(CeilToMultipleOf(split_width, align_x));
|
|
|
|
for (uint32_t count = 0; count < split_count; count++) {
|
|
float aligned_right = rect_temp.left + aligned_width;
|
|
out_rects[count].left = rect_temp.left;
|
|
out_rects[count].right = std::min(rect_temp.right, aligned_right);
|
|
out_rects[count].top = rect_temp.top;
|
|
out_rects[count].bottom = rect_temp.bottom;
|
|
|
|
rect_temp.left = out_rects[count].right;
|
|
|
|
Log(kTagRotator, "SplitLeftRight", out_rects[count]);
|
|
}
|
|
|
|
// If we have a horizontal flip, then we should be splitting the source from right to left
|
|
// to ensure that the right split will have an aligned width that matches the alignment on the
|
|
// destination.
|
|
if (flip_horizontal && split_count > 1) {
|
|
out_rects[0].right = out_rects[0].left + (out_rects[1].right - out_rects[1].left);
|
|
out_rects[1].left = out_rects[0].right;
|
|
Log(kTagRotator, "Adjusted Left", out_rects[0]);
|
|
Log(kTagRotator, "Adjusted Right", out_rects[1]);
|
|
}
|
|
}
|
|
|
|
void SplitTopBottom(const LayerRect &in_rect, uint32_t split_count, uint32_t align_y,
|
|
bool flip_horizontal, LayerRect *out_rects) {
|
|
LayerRect rect_temp = in_rect;
|
|
|
|
uint32_t split_height = UINT32(rect_temp.bottom - rect_temp.top) / split_count;
|
|
float aligned_height = FLOAT(CeilToMultipleOf(split_height, align_y));
|
|
|
|
for (uint32_t count = 0; count < split_count; count++) {
|
|
float aligned_bottom = rect_temp.top + aligned_height;
|
|
out_rects[count].top = rect_temp.top;
|
|
out_rects[count].bottom = std::min(rect_temp.bottom, aligned_bottom);
|
|
out_rects[count].left = rect_temp.left;
|
|
out_rects[count].right = rect_temp.right;
|
|
|
|
rect_temp.top = out_rects[count].bottom;
|
|
|
|
Log(kTagRotator, "SplitTopBottom", out_rects[count]);
|
|
}
|
|
|
|
// If we have a horizontal flip, then we should be splitting the destination from bottom to top
|
|
// to ensure that the bottom split's y-offset is aligned correctly after we swap the destinations
|
|
// while accounting for the flip.
|
|
if (flip_horizontal && split_count > 1) {
|
|
out_rects[0].bottom = out_rects[0].top + (out_rects[1].bottom - out_rects[1].top);
|
|
out_rects[1].top = out_rects[0].bottom;
|
|
Log(kTagRotator, "Adjusted Top", out_rects[0]);
|
|
Log(kTagRotator, "Adjusted Bottom", out_rects[1]);
|
|
}
|
|
}
|
|
|
|
void MapRect(const LayerRect &src_domain, const LayerRect &dst_domain, const LayerRect &in_rect,
|
|
LayerRect *out_rect) {
|
|
if (!IsValid(src_domain) || !IsValid(dst_domain) || !IsValid(in_rect)) {
|
|
return;
|
|
}
|
|
|
|
int x_offset = INT(src_domain.left);
|
|
int y_offset = INT(src_domain.top);
|
|
|
|
LayerRect modified_in_rect = Reposition(in_rect, -x_offset, -y_offset);
|
|
float src_domain_width = src_domain.right - src_domain.left;
|
|
float src_domain_height = src_domain.bottom - src_domain.top;
|
|
float dst_domain_width = dst_domain.right - dst_domain.left;
|
|
float dst_domain_height = dst_domain.bottom - dst_domain.top;
|
|
|
|
float width_ratio = dst_domain_width / src_domain_width;
|
|
float height_ratio = dst_domain_height / src_domain_height;
|
|
|
|
out_rect->left = dst_domain.left + (width_ratio * modified_in_rect.left);
|
|
out_rect->top = dst_domain.top + (height_ratio * modified_in_rect.top);
|
|
out_rect->right = dst_domain.left + (width_ratio * modified_in_rect.right);
|
|
out_rect->bottom = dst_domain.top + (height_ratio * modified_in_rect.bottom);
|
|
}
|
|
|
|
void TransformHV(const LayerRect &src_domain, const LayerRect &in_rect,
|
|
const LayerTransform &transform, LayerRect *out_rect) {
|
|
if (!IsValid(src_domain) || !IsValid(in_rect)) {
|
|
return;
|
|
}
|
|
|
|
float in_width = in_rect.right - in_rect.left;
|
|
float in_height = in_rect.bottom - in_rect.top;
|
|
float x_offset = in_rect.left - src_domain.left;
|
|
float y_offset = in_rect.top - src_domain.top;
|
|
*out_rect = in_rect;
|
|
|
|
if (transform.flip_horizontal) {
|
|
out_rect->right = src_domain.right - x_offset;
|
|
out_rect->left = out_rect->right - in_width;
|
|
}
|
|
|
|
if (transform.flip_vertical) {
|
|
out_rect->bottom = src_domain.bottom - y_offset;
|
|
out_rect->top = out_rect->bottom - in_height;
|
|
}
|
|
}
|
|
|
|
RectOrientation GetOrientation(const LayerRect &in_rect) {
|
|
if (!IsValid(in_rect)) {
|
|
return kOrientationUnknown;
|
|
}
|
|
|
|
float input_width = in_rect.right - in_rect.left;
|
|
float input_height = in_rect.bottom - in_rect.top;
|
|
|
|
if (input_width < input_height) {
|
|
return kOrientationPortrait;
|
|
}
|
|
|
|
return kOrientationLandscape;
|
|
}
|
|
|
|
DisplayError GetCropAndDestination(const LayerRect &crop, const LayerRect &dst,
|
|
const bool rotated90, float *crop_width,
|
|
float *crop_height, float *dst_width,
|
|
float *dst_height) {
|
|
if (!IsValid(crop)) {
|
|
Log(kTagResources, "Invalid crop rect", crop);
|
|
return kErrorNotSupported;
|
|
}
|
|
|
|
if (!IsValid(dst)) {
|
|
Log(kTagResources, "Invalid dst rect", dst);
|
|
return kErrorNotSupported;
|
|
}
|
|
|
|
*crop_width = crop.right - crop.left;
|
|
*crop_height = crop.bottom - crop.top;
|
|
if (rotated90) {
|
|
std::swap(*crop_width, *crop_height);
|
|
}
|
|
|
|
*dst_width = dst.right - dst.left;
|
|
*dst_height = dst.bottom - dst.top;
|
|
|
|
return kErrorNone;
|
|
}
|
|
|
|
DisplayError GetScaleFactor(const LayerRect &crop, const LayerRect &dst,
|
|
bool rotated90, float *scale_x, float *scale_y) {
|
|
float crop_width = 1.0f, crop_height = 1.0f, dst_width = 1.0f, dst_height = 1.0f;
|
|
|
|
DisplayError error = GetCropAndDestination(crop, dst, rotated90, &crop_width, &crop_height,
|
|
&dst_width, &dst_height);
|
|
if (error != kErrorNone) {
|
|
return error;
|
|
}
|
|
|
|
*scale_x = crop_width / dst_width;
|
|
*scale_y = crop_height / dst_height;
|
|
|
|
return kErrorNone;
|
|
}
|
|
|
|
} // namespace sdm
|
|
|