1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "Backend.h"
18
19 #include <climits>
20
21 #include "BackendManager.h"
22 #include "bufferinfo/BufferInfoGetter.h"
23
24 namespace android {
25
ValidateDisplay(HwcDisplay * display,uint32_t * num_types,uint32_t * num_requests)26 HWC2::Error Backend::ValidateDisplay(HwcDisplay *display, uint32_t *num_types,
27 uint32_t *num_requests) {
28 *num_types = 0;
29 *num_requests = 0;
30
31 auto layers = display->GetOrderLayersByZPos();
32
33 int client_start = -1;
34 size_t client_size = 0;
35
36 if (display->ProcessClientFlatteningState(layers.size() <= 1)) {
37 display->total_stats().frames_flattened_++;
38 client_start = 0;
39 client_size = layers.size();
40 MarkValidated(layers, client_start, client_size);
41 } else {
42 std::tie(client_start, client_size) = GetClientLayers(display, layers);
43
44 MarkValidated(layers, client_start, client_size);
45
46 bool testing_needed = !(client_start == 0 && client_size == layers.size());
47
48 AtomicCommitArgs a_args = {.test_only = true};
49
50 if (testing_needed &&
51 display->CreateComposition(a_args) != HWC2::Error::None) {
52 ++display->total_stats().failed_kms_validate_;
53 client_start = 0;
54 client_size = layers.size();
55 MarkValidated(layers, 0, client_size);
56 }
57 }
58
59 *num_types = client_size;
60
61 display->total_stats().gpu_pixops_ += CalcPixOps(layers, client_start,
62 client_size);
63 display->total_stats().total_pixops_ += CalcPixOps(layers, 0, layers.size());
64
65 return *num_types != 0 ? HWC2::Error::HasChanges : HWC2::Error::None;
66 }
67
GetClientLayers(HwcDisplay * display,const std::vector<HwcLayer * > & layers)68 std::tuple<int, size_t> Backend::GetClientLayers(
69 HwcDisplay *display, const std::vector<HwcLayer *> &layers) {
70 int client_start = -1;
71 size_t client_size = 0;
72
73 for (size_t z_order = 0; z_order < layers.size(); ++z_order) {
74 if (IsClientLayer(display, layers[z_order])) {
75 if (client_start < 0)
76 client_start = (int)z_order;
77 client_size = (z_order - client_start) + 1;
78 }
79 }
80
81 return GetExtraClientRange(display, layers, client_start, client_size);
82 }
83
IsClientLayer(HwcDisplay * display,HwcLayer * layer)84 bool Backend::IsClientLayer(HwcDisplay *display, HwcLayer *layer) {
85 return !HardwareSupportsLayerType(layer->GetSfType()) ||
86 !BufferInfoGetter::GetInstance()->IsHandleUsable(layer->GetBuffer()) ||
87 display->color_transform_hint() != HAL_COLOR_TRANSFORM_IDENTITY ||
88 (layer->RequireScalingOrPhasing() &&
89 display->GetHwc2()->GetResMan().ForcedScalingWithGpu());
90 }
91
HardwareSupportsLayerType(HWC2::Composition comp_type)92 bool Backend::HardwareSupportsLayerType(HWC2::Composition comp_type) {
93 return comp_type == HWC2::Composition::Device ||
94 comp_type == HWC2::Composition::Cursor;
95 }
96
CalcPixOps(const std::vector<HwcLayer * > & layers,size_t first_z,size_t size)97 uint32_t Backend::CalcPixOps(const std::vector<HwcLayer *> &layers,
98 size_t first_z, size_t size) {
99 uint32_t pixops = 0;
100 for (size_t z_order = 0; z_order < layers.size(); ++z_order) {
101 if (z_order >= first_z && z_order < first_z + size) {
102 hwc_rect_t df = layers[z_order]->GetDisplayFrame();
103 pixops += (df.right - df.left) * (df.bottom - df.top);
104 }
105 }
106 return pixops;
107 }
108
MarkValidated(std::vector<HwcLayer * > & layers,size_t client_first_z,size_t client_size)109 void Backend::MarkValidated(std::vector<HwcLayer *> &layers,
110 size_t client_first_z, size_t client_size) {
111 for (size_t z_order = 0; z_order < layers.size(); ++z_order) {
112 if (z_order >= client_first_z && z_order < client_first_z + client_size)
113 layers[z_order]->SetValidatedType(HWC2::Composition::Client);
114 else
115 layers[z_order]->SetValidatedType(HWC2::Composition::Device);
116 }
117 }
118
GetExtraClientRange(HwcDisplay * display,const std::vector<HwcLayer * > & layers,int client_start,size_t client_size)119 std::tuple<int, int> Backend::GetExtraClientRange(
120 HwcDisplay *display, const std::vector<HwcLayer *> &layers,
121 int client_start, size_t client_size) {
122 auto planes = display->GetPipe().GetUsablePlanes();
123 size_t avail_planes = planes.size();
124
125 /*
126 * If more layers then planes, save one plane
127 * for client composited layers
128 */
129 if (avail_planes < display->layers().size())
130 avail_planes--;
131
132 int extra_client = int(layers.size() - client_size) - int(avail_planes);
133
134 if (extra_client > 0) {
135 int start = 0;
136 size_t steps = 0;
137 if (client_size != 0) {
138 int prepend = std::min(client_start, extra_client);
139 int append = std::min(int(layers.size()) -
140 int(client_start + client_size),
141 extra_client);
142 start = client_start - (int)prepend;
143 client_size += extra_client;
144 steps = 1 + std::min(std::min(append, prepend),
145 int(layers.size()) - int(start + client_size));
146 } else {
147 client_size = extra_client;
148 steps = 1 + layers.size() - extra_client;
149 }
150
151 uint32_t gpu_pixops = UINT32_MAX;
152 for (size_t i = 0; i < steps; i++) {
153 uint32_t po = CalcPixOps(layers, start + i, client_size);
154 if (po < gpu_pixops) {
155 gpu_pixops = po;
156 client_start = start + int(i);
157 }
158 }
159 }
160
161 return std::make_tuple(client_start, client_size);
162 }
163
164 // clang-format off
165 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables, cert-err58-cpp)
166 REGISTER_BACKEND("generic", Backend);
167 // clang-format on
168
169 } // namespace android
170