summaryrefslogtreecommitdiff
path: root/libhwc2.1/libdisplayinterface/ExynosDeviceInterface.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libhwc2.1/libdisplayinterface/ExynosDeviceInterface.cpp')
-rw-r--r--libhwc2.1/libdisplayinterface/ExynosDeviceInterface.cpp183
1 files changed, 183 insertions, 0 deletions
diff --git a/libhwc2.1/libdisplayinterface/ExynosDeviceInterface.cpp b/libhwc2.1/libdisplayinterface/ExynosDeviceInterface.cpp
new file mode 100644
index 0000000..e3f50ba
--- /dev/null
+++ b/libhwc2.1/libdisplayinterface/ExynosDeviceInterface.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ExynosDeviceInterface.h"
+#include "ExynosHWCDebug.h"
+#include "ExynosDevice.h"
+#include "ExynosResourceManager.h"
+#include "ExynosMPP.h"
+#include <unordered_set>
+
+extern feature_support_t feature_table[];
+
+void ExynosDeviceInterface::printDppRestriction(struct dpp_ch_restriction res)
+{
+ ALOGD("=========================================================");
+ ALOGD("id: %d", res.id);
+ ALOGD("dpp_restriction");
+ ALOGD("src_f_w (%d, %d, %d)", res.restriction.src_f_w.min, res.restriction.src_f_w.max, res.restriction.src_f_w.align);
+ ALOGD("src_f_h (%d, %d, %d)", res.restriction.src_f_h.min, res.restriction.src_f_h.max, res.restriction.src_f_h.align);
+ ALOGD("src_w (%d, %d, %d)", res.restriction.src_w.min, res.restriction.src_w.max, res.restriction.src_w.align);
+ ALOGD("src_h (%d, %d, %d)", res.restriction.src_h.min, res.restriction.src_h.max, res.restriction.src_h.align);
+ ALOGD("src_x_align(%d), src_y_align(%d)", res.restriction.src_x_align, res.restriction.src_y_align);
+
+ ALOGD("dst_f_w (%d, %d, %d)", res.restriction.dst_f_w.min, res.restriction.dst_f_w.max, res.restriction.dst_f_w.align);
+ ALOGD("dst_f_h (%d, %d, %d)", res.restriction.dst_f_h.min, res.restriction.dst_f_h.max, res.restriction.dst_f_h.align);
+ ALOGD("dst_w (%d, %d, %d)", res.restriction.dst_w.min, res.restriction.dst_w.max, res.restriction.dst_w.align);
+ ALOGD("dst_h (%d, %d, %d)", res.restriction.dst_h.min, res.restriction.dst_h.max, res.restriction.dst_h.align);
+ ALOGD("dst_x_align(%d), dst_y_align(%d)", res.restriction.dst_x_align, res.restriction.dst_y_align);
+ ALOGD("src_h_rot_max(%d)", res.restriction.src_h_rot_max);
+
+ ALOGD("blk_w (%d, %d, %d)", res.restriction.blk_w.min, res.restriction.blk_w.max, res.restriction.blk_w.align);
+ ALOGD("blk_h (%d, %d, %d)", res.restriction.blk_h.min, res.restriction.blk_h.max, res.restriction.blk_h.align);
+ ALOGD("blk_x_align(%d), blk_y_align(%d)", res.restriction.blk_x_align, res.restriction.blk_y_align);
+
+ ALOGD("format cnt: %d", res.restriction.format_cnt);
+ for(int i = 0; i < res.restriction.format_cnt; i++) {
+ ALOGD("[%d] format: %d", i, res.restriction.format[i]);
+ }
+
+ ALOGD("scale down: %d, up: %d", res.restriction.scale_down, res.restriction.scale_up);
+ ALOGD("attr: 0x%lx", res.attr);
+}
+
+int32_t ExynosDeviceInterface::makeDPURestrictions() {
+ int32_t ret = 0;
+
+ struct dpp_restrictions_info *dpuInfo = &mDPUInfo.dpuInfo;
+ HDEBUGLOGD(eDebugDefault, "DPP ver : %d, cnt : %d", dpuInfo->ver, dpuInfo->dpp_cnt);
+ ExynosResourceManager *resourceManager = mExynosDevice->mResourceManager;
+
+ /* format resctriction */
+ for (int i = 0; i < dpuInfo->dpp_cnt; i++){
+ dpp_restriction r = dpuInfo->dpp_ch[i].restriction;
+ HDEBUGLOGD(eDebugDefault, "id : %d, format count : %d", i, r.format_cnt);
+ }
+
+ /* Check attribute overlap */
+ std::unordered_set<unsigned long> attrs;
+ for (size_t i = 0; i < dpuInfo->dpp_cnt; ++i) {
+ const dpp_ch_restriction &r = dpuInfo->dpp_ch[i];
+ if (attrs.count(r.attr))
+ mDPUInfo.overlap[i] = true;
+ else
+ attrs.insert(r.attr);
+ HDEBUGLOGD(eDebugDefault, "Index : %zu, overlap %d", i, mDPUInfo.overlap[i]);
+ }
+
+ for (int i = 0; i < dpuInfo->dpp_cnt; i++){
+ if (mDPUInfo.overlap[i]) continue;
+ dpp_restriction r = dpuInfo->dpp_ch[i].restriction;
+ mpp_phycal_type_t hwType = resourceManager->getPhysicalType(i);
+ for (int j = 0; j < r.format_cnt; j++){
+ restriction_key_t queried_format;
+ queried_format.hwType = hwType;
+ queried_format.nodeType = NODE_NONE;
+ /* r.format[j] is HAL format */
+ queried_format.format = r.format[j];
+ queried_format.reserved = 0;
+ resourceManager->makeFormatRestrictions(queried_format);
+ HDEBUGLOGD(eDebugDefault, "%s : %d", getMPPStr(hwType).string(), r.format[j]);
+ }
+ }
+
+ for (int i = 0; i < dpuInfo->dpp_cnt; i++){
+ if (mDPUInfo.overlap[i]) continue;
+ const dpp_restriction &r = dpuInfo->dpp_ch[i].restriction;
+
+ /* RGB size restrictions */
+ restriction_size rSize;
+ rSize.maxDownScale = r.scale_down;
+ rSize.maxUpScale = r.scale_up;
+ rSize.maxFullWidth = r.dst_f_w.max;
+ rSize.maxFullHeight = r.dst_f_h.max;
+ rSize.minFullWidth = r.dst_f_w.min;
+ rSize.minFullHeight = r.dst_f_h.min;;
+ rSize.fullWidthAlign = r.dst_x_align;
+ rSize.fullHeightAlign = r.dst_y_align;;
+ rSize.maxCropWidth = r.src_w.max;
+ rSize.maxCropHeight = r.src_h.max;
+ rSize.minCropWidth = r.src_w.min;
+ rSize.minCropHeight = r.src_h.min;
+ rSize.cropXAlign = r.src_x_align;
+ rSize.cropYAlign = r.src_y_align;
+ rSize.cropWidthAlign = r.blk_x_align;
+ rSize.cropHeightAlign = r.blk_y_align;
+
+ mpp_phycal_type_t hwType = resourceManager->getPhysicalType(i);
+ resourceManager->makeSizeRestrictions(hwType, rSize, RESTRICTION_RGB);
+
+ /* YUV size restrictions */
+ rSize.minCropWidth = 32; //r.src_w.min;
+ rSize.minCropHeight = 32; //r.src_h.min;
+ rSize.fullWidthAlign = max(r.dst_x_align, YUV_CHROMA_H_SUBSAMPLE);
+ rSize.fullHeightAlign = max(r.dst_y_align, YUV_CHROMA_V_SUBSAMPLE);
+ rSize.cropXAlign = max(r.src_x_align, YUV_CHROMA_H_SUBSAMPLE);
+ rSize.cropYAlign = max(r.src_y_align, YUV_CHROMA_V_SUBSAMPLE);
+ rSize.cropWidthAlign = max(r.blk_x_align, YUV_CHROMA_H_SUBSAMPLE);
+ rSize.cropHeightAlign = max(r.blk_y_align, YUV_CHROMA_V_SUBSAMPLE);
+
+ resourceManager->makeSizeRestrictions(hwType, rSize, RESTRICTION_YUV);
+ }
+ return ret;
+}
+
+int32_t ExynosDeviceInterface::updateFeatureTable() {
+ const struct dpp_restrictions_info &dpuInfo = mDPUInfo.dpuInfo;
+ if (mExynosDevice->mResourceManager == NULL)
+ return -1;
+
+ const ExynosResourceManager &resourceManager = *(mExynosDevice->mResourceManager);
+ const uint32_t featureTableCnt = resourceManager.getFeatureTableSize();
+
+ const int attrMapCnt = sizeof(dpu_attr_map_table)/sizeof(dpu_attr_map_t);
+ const int dpp_cnt = dpuInfo.dpp_cnt;
+
+ HDEBUGLOGD(eDebugDefault, "Before");
+ for (uint32_t j = 0; j < featureTableCnt; j++){
+ HDEBUGLOGD(eDebugDefault, "type : %d, feature : 0x%lx",
+ feature_table[j].hwType,
+ (unsigned long)feature_table[j].attr);
+ }
+
+ // dpp count
+ for (int i = 0; i < dpp_cnt; i++){
+ dpp_ch_restriction c_r = dpuInfo.dpp_ch[i];
+ if (mDPUInfo.overlap[i]) continue;
+ HDEBUGLOGD(eDebugDefault, "DPU attr : (ch:%d), 0x%lx", i, (unsigned long)c_r.attr);
+ mpp_phycal_type_t hwType = resourceManager.getPhysicalType(i);
+ // feature table count
+ for (uint32_t j = 0; j < featureTableCnt; j++){
+ if (feature_table[j].hwType == hwType) {
+ // dpp attr count
+ for (int k = 0; k < attrMapCnt; k++) {
+ if (c_r.attr & (1 << dpu_attr_map_table[k].dpp_attr)) {
+ feature_table[j].attr |= dpu_attr_map_table[k].hwc_attr;
+ }
+ }
+ }
+ }
+ }
+
+ HDEBUGLOGD(eDebugDefault, "After");
+ for (uint32_t j = 0; j < featureTableCnt; j++){
+ HDEBUGLOGD(eDebugDefault, "type : %d, feature : 0x%lx",
+ feature_table[j].hwType,
+ (unsigned long)feature_table[j].attr);
+ }
+ return 0;
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-03 13:26:40 +0000