1 /*
2  * Copyright 2016 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 #ifndef ANDROID_SURFACEINTERCEPTOR_H
18 #define ANDROID_SURFACEINTERCEPTOR_H
19 
20 #include <frameworks/native/cmds/surfacereplayer/proto/src/trace.pb.h>
21 
22 #include <mutex>
23 
24 #include <gui/LayerState.h>
25 
26 #include <utils/KeyedVector.h>
27 #include <utils/SortedVector.h>
28 #include <utils/StrongPointer.h>
29 #include <utils/Vector.h>
30 
31 #include "DisplayDevice.h"
32 
33 namespace android {
34 
35 class BufferItem;
36 class Layer;
37 class SurfaceFlinger;
38 struct ComposerState;
39 struct DisplayDeviceState;
40 struct DisplayState;
41 struct layer_state_t;
42 
43 constexpr auto DEFAULT_FILENAME = "/data/SurfaceTrace.dat";
44 
45 class SurfaceInterceptor {
46 public:
47     virtual ~SurfaceInterceptor();
48 
49     // Both vectors are used to capture the current state of SF as the initial snapshot in the trace
50     virtual void enable(const SortedVector<sp<Layer>>& layers,
51                         const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays) = 0;
52     virtual void disable() = 0;
53     virtual bool isEnabled() = 0;
54 
55     // Intercept display and surface transactions
56     virtual void saveTransaction(
57             const Vector<ComposerState>& stateUpdates,
58             const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
59             const Vector<DisplayState>& changedDisplays, uint32_t flags) = 0;
60 
61     // Intercept surface data
62     virtual void saveSurfaceCreation(const sp<const Layer>& layer) = 0;
63     virtual void saveSurfaceDeletion(const sp<const Layer>& layer) = 0;
64     virtual void saveBufferUpdate(const sp<const Layer>& layer, uint32_t width, uint32_t height,
65                                   uint64_t frameNumber) = 0;
66 
67     // Intercept display data
68     virtual void saveDisplayCreation(const DisplayDeviceState& info) = 0;
69     virtual void saveDisplayDeletion(int32_t sequenceId) = 0;
70     virtual void savePowerModeUpdate(int32_t sequenceId, int32_t mode) = 0;
71     virtual void saveVSyncEvent(nsecs_t timestamp) = 0;
72 };
73 
74 namespace impl {
75 
76 /*
77  * SurfaceInterceptor intercepts and stores incoming streams of window
78  * properties on SurfaceFlinger.
79  */
80 class SurfaceInterceptor final : public android::SurfaceInterceptor {
81 public:
82     explicit SurfaceInterceptor(SurfaceFlinger* const flinger);
83     ~SurfaceInterceptor() override = default;
84 
85     // Both vectors are used to capture the current state of SF as the initial snapshot in the trace
86     void enable(const SortedVector<sp<Layer>>& layers,
87                 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays) override;
88     void disable() override;
89     bool isEnabled() override;
90 
91     // Intercept display and surface transactions
92     void saveTransaction(const Vector<ComposerState>& stateUpdates,
93                          const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
94                          const Vector<DisplayState>& changedDisplays, uint32_t flags) override;
95 
96     // Intercept surface data
97     void saveSurfaceCreation(const sp<const Layer>& layer) override;
98     void saveSurfaceDeletion(const sp<const Layer>& layer) override;
99     void saveBufferUpdate(const sp<const Layer>& layer, uint32_t width, uint32_t height,
100                           uint64_t frameNumber) override;
101 
102     // Intercept display data
103     void saveDisplayCreation(const DisplayDeviceState& info) override;
104     void saveDisplayDeletion(int32_t sequenceId) override;
105     void savePowerModeUpdate(int32_t sequenceId, int32_t mode) override;
106     void saveVSyncEvent(nsecs_t timestamp) override;
107 
108 private:
109     // The creation increments of Surfaces and Displays do not contain enough information to capture
110     // the initial state of each object, so a transaction with all of the missing properties is
111     // performed at the initial snapshot for each display and surface.
112     void saveExistingDisplaysLocked(
113             const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays);
114     void saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers);
115     void addInitialSurfaceStateLocked(Increment* increment, const sp<const Layer>& layer);
116     void addInitialDisplayStateLocked(Increment* increment, const DisplayDeviceState& display);
117 
118     status_t writeProtoFileLocked();
119     const sp<const Layer> getLayer(const wp<const IBinder>& weakHandle);
120     const std::string getLayerName(const sp<const Layer>& layer);
121     int32_t getLayerId(const sp<const Layer>& layer);
122 
123     Increment* createTraceIncrementLocked();
124     void addSurfaceCreationLocked(Increment* increment, const sp<const Layer>& layer);
125     void addSurfaceDeletionLocked(Increment* increment, const sp<const Layer>& layer);
126     void addBufferUpdateLocked(Increment* increment, const sp<const Layer>& layer, uint32_t width,
127             uint32_t height, uint64_t frameNumber);
128     void addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp);
129     void addDisplayCreationLocked(Increment* increment, const DisplayDeviceState& info);
130     void addDisplayDeletionLocked(Increment* increment, int32_t sequenceId);
131     void addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId, int32_t mode);
132 
133     // Add surface transactions to the trace
134     SurfaceChange* createSurfaceChangeLocked(Transaction* transaction, int32_t layerId);
135     void setProtoRectLocked(Rectangle* protoRect, const Rect& rect);
136     void addPositionLocked(Transaction* transaction, int32_t layerId, float x, float y);
137     void addDepthLocked(Transaction* transaction, int32_t layerId, uint32_t z);
138     void addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w, uint32_t h);
139     void addAlphaLocked(Transaction* transaction, int32_t layerId, float alpha);
140     void addMatrixLocked(Transaction* transaction, int32_t layerId,
141             const layer_state_t::matrix22_t& matrix);
142     void addTransparentRegionLocked(Transaction* transaction, int32_t layerId,
143             const Region& transRegion);
144     void addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags);
145     void addLayerStackLocked(Transaction* transaction, int32_t layerId, uint32_t layerStack);
146     void addCropLocked(Transaction* transaction, int32_t layerId, const Rect& rect);
147     void addCornerRadiusLocked(Transaction* transaction, int32_t layerId, float cornerRadius);
148     void addDeferTransactionLocked(Transaction* transaction, int32_t layerId,
149             const sp<const Layer>& layer, uint64_t frameNumber);
150     void addOverrideScalingModeLocked(Transaction* transaction, int32_t layerId,
151             int32_t overrideScalingMode);
152     void addSurfaceChangesLocked(Transaction* transaction, const layer_state_t& state);
153     void addTransactionLocked(Increment* increment, const Vector<ComposerState>& stateUpdates,
154             const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays,
155             const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags);
156 
157     // Add display transactions to the trace
158     DisplayChange* createDisplayChangeLocked(Transaction* transaction, int32_t sequenceId);
159     void addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId,
160             const sp<const IGraphicBufferProducer>& surface);
161     void addDisplayLayerStackLocked(Transaction* transaction, int32_t sequenceId,
162             uint32_t layerStack);
163     void addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId, uint32_t w,
164             uint32_t h);
165     void addDisplayProjectionLocked(Transaction* transaction, int32_t sequenceId,
166             int32_t orientation, const Rect& viewport, const Rect& frame);
167     void addDisplayChangesLocked(Transaction* transaction,
168             const DisplayState& state, int32_t sequenceId);
169 
170 
171     bool mEnabled {false};
172     std::string mOutputFileName {DEFAULT_FILENAME};
173     std::mutex mTraceMutex {};
174     Trace mTrace {};
175     SurfaceFlinger* const mFlinger;
176 };
177 
178 } // namespace impl
179 } // namespace android
180 
181 #endif // ANDROID_SURFACEINTERCEPTOR_H
182