1 /*
2  * Copyright (C) 2017 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 #include <android-base/stringprintf.h>
17 #include <layerproto/LayerProtoParser.h>
18 #include <ui/DebugUtils.h>
19 
20 using android::base::StringAppendF;
21 using android::base::StringPrintf;
22 
23 namespace android {
24 namespace surfaceflinger {
25 
sortLayers(LayerProtoParser::Layer * lhs,const LayerProtoParser::Layer * rhs)26 bool sortLayers(LayerProtoParser::Layer* lhs, const LayerProtoParser::Layer* rhs) {
27     uint32_t ls = lhs->layerStack;
28     uint32_t rs = rhs->layerStack;
29     if (ls != rs) return ls < rs;
30 
31     int32_t lz = lhs->z;
32     int32_t rz = rhs->z;
33     if (lz != rz) {
34         return lz < rz;
35     }
36 
37     return lhs->id < rhs->id;
38 }
39 
generateLayerTree(const LayersProto & layersProto)40 LayerProtoParser::LayerTree LayerProtoParser::generateLayerTree(const LayersProto& layersProto) {
41     LayerTree layerTree;
42     layerTree.allLayers = generateLayerList(layersProto);
43 
44     // find and sort the top-level layers
45     for (Layer& layer : layerTree.allLayers) {
46         if (layer.parent == nullptr) {
47             layerTree.topLevelLayers.push_back(&layer);
48         }
49     }
50     std::sort(layerTree.topLevelLayers.begin(), layerTree.topLevelLayers.end(), sortLayers);
51 
52     return layerTree;
53 }
54 
generateLayerList(const LayersProto & layersProto)55 std::vector<LayerProtoParser::Layer> LayerProtoParser::generateLayerList(
56         const LayersProto& layersProto) {
57     std::vector<Layer> layerList;
58     std::unordered_map<int32_t, Layer*> layerMap;
59 
60     // build the layer list and the layer map
61     layerList.reserve(layersProto.layers_size());
62     layerMap.reserve(layersProto.layers_size());
63     for (int i = 0; i < layersProto.layers_size(); i++) {
64         layerList.emplace_back(generateLayer(layersProto.layers(i)));
65         // this works because layerList never changes capacity
66         layerMap[layerList.back().id] = &layerList.back();
67     }
68 
69     // fix up children and relatives
70     for (int i = 0; i < layersProto.layers_size(); i++) {
71         updateChildrenAndRelative(layersProto.layers(i), layerMap);
72     }
73 
74     return layerList;
75 }
76 
generateLayer(const LayerProto & layerProto)77 LayerProtoParser::Layer LayerProtoParser::generateLayer(const LayerProto& layerProto) {
78     Layer layer;
79     layer.id = layerProto.id();
80     layer.name = layerProto.name();
81     layer.type = layerProto.type();
82     layer.transparentRegion = generateRegion(layerProto.transparent_region());
83     layer.visibleRegion = generateRegion(layerProto.visible_region());
84     layer.damageRegion = generateRegion(layerProto.damage_region());
85     layer.layerStack = layerProto.layer_stack();
86     layer.z = layerProto.z();
87     layer.position = {layerProto.position().x(), layerProto.position().y()};
88     layer.requestedPosition = {layerProto.requested_position().x(),
89                                 layerProto.requested_position().y()};
90     layer.size = {layerProto.size().w(), layerProto.size().h()};
91     layer.crop = generateRect(layerProto.crop());
92     layer.isOpaque = layerProto.is_opaque();
93     layer.invalidate = layerProto.invalidate();
94     layer.dataspace = layerProto.dataspace();
95     layer.pixelFormat = layerProto.pixel_format();
96     layer.color = {layerProto.color().r(), layerProto.color().g(), layerProto.color().b(),
97                     layerProto.color().a()};
98     layer.requestedColor = {layerProto.requested_color().r(), layerProto.requested_color().g(),
99                              layerProto.requested_color().b(), layerProto.requested_color().a()};
100     layer.flags = layerProto.flags();
101     layer.transform = generateTransform(layerProto.transform());
102     layer.requestedTransform = generateTransform(layerProto.requested_transform());
103     layer.activeBuffer = generateActiveBuffer(layerProto.active_buffer());
104     layer.bufferTransform = generateTransform(layerProto.buffer_transform());
105     layer.queuedFrames = layerProto.queued_frames();
106     layer.refreshPending = layerProto.refresh_pending();
107     layer.isProtected = layerProto.is_protected();
108     layer.cornerRadius = layerProto.corner_radius();
109     layer.backgroundBlurRadius = layerProto.background_blur_radius();
110     for (const auto& entry : layerProto.metadata()) {
111         const std::string& dataStr = entry.second;
112         std::vector<uint8_t>& outData = layer.metadata.mMap[entry.first];
113         outData.resize(dataStr.size());
114         memcpy(outData.data(), dataStr.data(), dataStr.size());
115     }
116     layer.cornerRadiusCrop = generateFloatRect(layerProto.corner_radius_crop());
117     layer.shadowRadius = layerProto.shadow_radius();
118     return layer;
119 }
120 
generateRegion(const RegionProto & regionProto)121 LayerProtoParser::Region LayerProtoParser::generateRegion(const RegionProto& regionProto) {
122     LayerProtoParser::Region region;
123     for (int i = 0; i < regionProto.rect_size(); i++) {
124         const RectProto& rectProto = regionProto.rect(i);
125         region.rects.push_back(generateRect(rectProto));
126     }
127 
128     return region;
129 }
130 
generateRect(const RectProto & rectProto)131 LayerProtoParser::Rect LayerProtoParser::generateRect(const RectProto& rectProto) {
132     LayerProtoParser::Rect rect;
133     rect.left = rectProto.left();
134     rect.top = rectProto.top();
135     rect.right = rectProto.right();
136     rect.bottom = rectProto.bottom();
137 
138     return rect;
139 }
140 
generateFloatRect(const FloatRectProto & rectProto)141 LayerProtoParser::FloatRect LayerProtoParser::generateFloatRect(const FloatRectProto& rectProto) {
142     LayerProtoParser::FloatRect rect;
143     rect.left = rectProto.left();
144     rect.top = rectProto.top();
145     rect.right = rectProto.right();
146     rect.bottom = rectProto.bottom();
147 
148     return rect;
149 }
150 
generateTransform(const TransformProto & transformProto)151 LayerProtoParser::Transform LayerProtoParser::generateTransform(
152         const TransformProto& transformProto) {
153     LayerProtoParser::Transform transform;
154     transform.dsdx = transformProto.dsdx();
155     transform.dtdx = transformProto.dtdx();
156     transform.dsdy = transformProto.dsdy();
157     transform.dtdy = transformProto.dtdy();
158 
159     return transform;
160 }
161 
generateActiveBuffer(const ActiveBufferProto & activeBufferProto)162 LayerProtoParser::ActiveBuffer LayerProtoParser::generateActiveBuffer(
163         const ActiveBufferProto& activeBufferProto) {
164     LayerProtoParser::ActiveBuffer activeBuffer;
165     activeBuffer.width = activeBufferProto.width();
166     activeBuffer.height = activeBufferProto.height();
167     activeBuffer.stride = activeBufferProto.stride();
168     activeBuffer.format = activeBufferProto.format();
169 
170     return activeBuffer;
171 }
172 
updateChildrenAndRelative(const LayerProto & layerProto,std::unordered_map<int32_t,Layer * > & layerMap)173 void LayerProtoParser::updateChildrenAndRelative(const LayerProto& layerProto,
174                                                  std::unordered_map<int32_t, Layer*>& layerMap) {
175     auto currLayer = layerMap[layerProto.id()];
176 
177     for (int i = 0; i < layerProto.children_size(); i++) {
178         if (layerMap.count(layerProto.children(i)) > 0) {
179             currLayer->children.push_back(layerMap[layerProto.children(i)]);
180         }
181     }
182 
183     for (int i = 0; i < layerProto.relatives_size(); i++) {
184         if (layerMap.count(layerProto.relatives(i)) > 0) {
185             currLayer->relatives.push_back(layerMap[layerProto.relatives(i)]);
186         }
187     }
188 
189     if (layerProto.parent() != -1) {
190         if (layerMap.count(layerProto.parent()) > 0) {
191             currLayer->parent = layerMap[layerProto.parent()];
192         }
193     }
194 
195     if (layerProto.z_order_relative_of() != -1) {
196         if (layerMap.count(layerProto.z_order_relative_of()) > 0) {
197             currLayer->zOrderRelativeOf = layerMap[layerProto.z_order_relative_of()];
198         }
199     }
200 }
201 
layerTreeToString(const LayerTree & layerTree)202 std::string LayerProtoParser::layerTreeToString(const LayerTree& layerTree) {
203     std::string result;
204     for (const LayerProtoParser::Layer* layer : layerTree.topLevelLayers) {
205         if (layer->zOrderRelativeOf != nullptr) {
206             continue;
207         }
208         result.append(layerToString(layer));
209     }
210 
211     return result;
212 }
213 
layerToString(const LayerProtoParser::Layer * layer)214 std::string LayerProtoParser::layerToString(const LayerProtoParser::Layer* layer) {
215     std::string result;
216 
217     std::vector<Layer*> traverse(layer->relatives);
218     for (LayerProtoParser::Layer* child : layer->children) {
219         if (child->zOrderRelativeOf != nullptr) {
220             continue;
221         }
222 
223         traverse.push_back(child);
224     }
225 
226     std::sort(traverse.begin(), traverse.end(), sortLayers);
227 
228     size_t i = 0;
229     for (; i < traverse.size(); i++) {
230         auto& relative = traverse[i];
231         if (relative->z >= 0) {
232             break;
233         }
234         result.append(layerToString(relative));
235     }
236     result.append(layer->to_string());
237     result.append("\n");
238     for (; i < traverse.size(); i++) {
239         auto& relative = traverse[i];
240         result.append(layerToString(relative));
241     }
242 
243     return result;
244 }
245 
to_string() const246 std::string LayerProtoParser::ActiveBuffer::to_string() const {
247     return StringPrintf("[%4ux%4u:%4u,%s]", width, height, stride,
248                         decodePixelFormat(format).c_str());
249 }
250 
to_string() const251 std::string LayerProtoParser::Transform::to_string() const {
252     return StringPrintf("[%.2f, %.2f][%.2f, %.2f]", static_cast<double>(dsdx),
253                         static_cast<double>(dtdx), static_cast<double>(dsdy),
254                         static_cast<double>(dtdy));
255 }
256 
to_string() const257 std::string LayerProtoParser::Rect::to_string() const {
258     return StringPrintf("[%3d, %3d, %3d, %3d]", left, top, right, bottom);
259 }
260 
to_string() const261 std::string LayerProtoParser::FloatRect::to_string() const {
262     return StringPrintf("[%.2f, %.2f, %.2f, %.2f]", left, top, right, bottom);
263 }
264 
to_string(const char * what) const265 std::string LayerProtoParser::Region::to_string(const char* what) const {
266     std::string result =
267             StringPrintf("  Region %s (this=%lx count=%d)\n", what, static_cast<unsigned long>(id),
268                          static_cast<int>(rects.size()));
269 
270     for (auto& rect : rects) {
271         StringAppendF(&result, "    %s\n", rect.to_string().c_str());
272     }
273 
274     return result;
275 }
276 
to_string() const277 std::string LayerProtoParser::Layer::to_string() const {
278     std::string result;
279     StringAppendF(&result, "+ %s (%s)\n", type.c_str(), name.c_str());
280     result.append(transparentRegion.to_string("TransparentRegion").c_str());
281     result.append(visibleRegion.to_string("VisibleRegion").c_str());
282     result.append(damageRegion.to_string("SurfaceDamageRegion").c_str());
283 
284     StringAppendF(&result, "      layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), ", layerStack,
285                   z, static_cast<double>(position.x), static_cast<double>(position.y), size.x,
286                   size.y);
287 
288     StringAppendF(&result, "crop=%s, ", crop.to_string().c_str());
289     StringAppendF(&result, "cornerRadius=%f, ", cornerRadius);
290     StringAppendF(&result, "isProtected=%1d, ", isProtected);
291     StringAppendF(&result, "isOpaque=%1d, invalidate=%1d, ", isOpaque, invalidate);
292     StringAppendF(&result, "dataspace=%s, ", dataspace.c_str());
293     StringAppendF(&result, "defaultPixelFormat=%s, ", pixelFormat.c_str());
294     StringAppendF(&result, "backgroundBlurRadius=%1d, ", backgroundBlurRadius);
295     StringAppendF(&result, "color=(%.3f,%.3f,%.3f,%.3f), flags=0x%08x, ",
296                   static_cast<double>(color.r), static_cast<double>(color.g),
297                   static_cast<double>(color.b), static_cast<double>(color.a), flags);
298     StringAppendF(&result, "tr=%s", transform.to_string().c_str());
299     result.append("\n");
300     StringAppendF(&result, "      parent=%s\n", parent == nullptr ? "none" : parent->name.c_str());
301     StringAppendF(&result, "      zOrderRelativeOf=%s\n",
302                   zOrderRelativeOf == nullptr ? "none" : zOrderRelativeOf->name.c_str());
303     StringAppendF(&result, "      activeBuffer=%s,", activeBuffer.to_string().c_str());
304     StringAppendF(&result, " tr=%s", bufferTransform.to_string().c_str());
305     StringAppendF(&result, " queued-frames=%d, mRefreshPending=%d,", queuedFrames, refreshPending);
306     StringAppendF(&result, " metadata={");
307     bool first = true;
308     for (const auto& entry : metadata.mMap) {
309         if (!first) result.append(", ");
310         first = false;
311         result.append(metadata.itemToString(entry.first, ":"));
312     }
313     result.append("},");
314     StringAppendF(&result, " cornerRadiusCrop=%s, ", cornerRadiusCrop.to_string().c_str());
315     StringAppendF(&result, " shadowRadius=%.3f, ", shadowRadius);
316     return result;
317 }
318 
319 } // namespace surfaceflinger
320 } // namespace android
321