1 #ifndef ANDROID_DVR_DISPLAY_PROTOCOL_H_
2 #define ANDROID_DVR_DISPLAY_PROTOCOL_H_
3 
4 #include <sys/types.h>
5 
6 #include <array>
7 #include <map>
8 
9 #include <dvr/dvr_display_types.h>
10 
11 #include <dvr/dvr_api.h>
12 #include <pdx/rpc/buffer_wrapper.h>
13 #include <pdx/rpc/remote_method.h>
14 #include <pdx/rpc/serializable.h>
15 #include <pdx/rpc/variant.h>
16 #include <private/dvr/bufferhub_rpc.h>
17 
18 // RPC protocol definitions for DVR display services (VrFlinger).
19 
20 namespace android {
21 namespace dvr {
22 namespace display {
23 
24 // Native display metrics.
25 struct Metrics {
26   // Basic display properties.
27   uint32_t display_width;
28   uint32_t display_height;
29   uint32_t display_x_dpi;
30   uint32_t display_y_dpi;
31   uint32_t vsync_period_ns;
32 
33   // HMD metrics.
34   // TODO(eieio): Determine how these fields should be populated. On phones
35   // these values are determined at runtime by VrCore based on which headset the
36   // phone is in. On dedicated hardware this needs to come from somewhere else.
37   // Perhaps these should be moved to a separate structure that is returned by a
38   // separate runtime call.
39   uint32_t distorted_width;
40   uint32_t distorted_height;
41   uint32_t hmd_ipd_mm;
42   float inter_lens_distance_m;
43   std::array<float, 4> left_fov_lrbt;
44   std::array<float, 4> right_fov_lrbt;
45 
46  private:
47   PDX_SERIALIZABLE_MEMBERS(Metrics, display_width, display_height,
48                            display_x_dpi, display_y_dpi, vsync_period_ns,
49                            distorted_width, distorted_height, hmd_ipd_mm,
50                            inter_lens_distance_m, left_fov_lrbt,
51                            right_fov_lrbt);
52 };
53 
54 // Serializable base type for enum structs. Enum structs are easier to use than
55 // enum classes, especially for bitmasks. This base type provides common
56 // utilities for flags types.
57 template <typename Integer>
58 class Flags {
59  public:
60   using Base = Flags<Integer>;
61   using Type = Integer;
62 
63   // NOLINTNEXTLINE(google-explicit-constructor)
Flags(const Integer & value)64   Flags(const Integer& value) : value_{value} {}
65   Flags(const Flags&) = default;
66   Flags& operator=(const Flags&) = default;
67 
value()68   Integer value() const { return value_; }
69   // NOLINTNEXTLINE(google-explicit-constructor)
Integer()70   operator Integer() const { return value_; }
71 
IsSet(Integer bits)72   bool IsSet(Integer bits) const { return (value_ & bits) == bits; }
IsClear(Integer bits)73   bool IsClear(Integer bits) const { return (value_ & bits) == 0; }
74 
Set(Integer bits)75   void Set(Integer bits) { value_ |= bits; }
Clear(Integer bits)76   void Clear(Integer bits) { value_ &= ~bits; }
77 
78   Integer operator|(Integer bits) const { return value_ | bits; }
79   Integer operator&(Integer bits) const { return value_ & bits; }
80 
81   Flags& operator|=(Integer bits) {
82     value_ |= bits;
83     return *this;
84   }
85   Flags& operator&=(Integer bits) {
86     value_ &= bits;
87     return *this;
88   }
89 
90  private:
91   Integer value_;
92 
93   PDX_SERIALIZABLE_MEMBERS(Flags<Integer>, value_);
94 };
95 
96 // Flags indicating what changed since last update.
97 struct SurfaceUpdateFlags : public Flags<uint32_t> {
98   enum : Type {
99     None = DVR_SURFACE_UPDATE_FLAGS_NONE,
100     NewSurface = DVR_SURFACE_UPDATE_FLAGS_NEW_SURFACE,
101     BuffersChanged = DVR_SURFACE_UPDATE_FLAGS_BUFFERS_CHANGED,
102     VisibilityChanged = DVR_SURFACE_UPDATE_FLAGS_VISIBILITY_CHANGED,
103     AttributesChanged = DVR_SURFACE_UPDATE_FLAGS_ATTRIBUTES_CHANGED,
104   };
105 
SurfaceUpdateFlagsSurfaceUpdateFlags106   SurfaceUpdateFlags() : Base{None} {}
107   using Base::Base;
108 };
109 
110 // Surface attribute key/value types.
111 using SurfaceAttributeKey = int32_t;
112 using SurfaceAttributeValue =
113     pdx::rpc::Variant<int32_t, int64_t, bool, float, std::array<float, 2>,
114                       std::array<float, 3>, std::array<float, 4>,
115                       std::array<float, 8>, std::array<float, 16>>;
116 
117 // Defined surface attribute keys.
118 struct SurfaceAttribute : public Flags<SurfaceAttributeKey> {
119   enum : Type {
120     // Keys in the negative integer space are interpreted by VrFlinger for
121     // direct surfaces.
122     Direct = DVR_SURFACE_ATTRIBUTE_DIRECT,
123     ZOrder = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
124     Visible = DVR_SURFACE_ATTRIBUTE_VISIBLE,
125 
126     // Invalid key. May be used to terminate C style lists in public API code.
127     Invalid = DVR_SURFACE_ATTRIBUTE_INVALID,
128 
129     // Positive keys are interpreted by the compositor only.
130     FirstUserKey = DVR_SURFACE_ATTRIBUTE_FIRST_USER_KEY,
131   };
132 
SurfaceAttributeSurfaceAttribute133   SurfaceAttribute() : Base{Invalid} {}
134   using Base::Base;
135 };
136 
137 // Collection of surface attribute key/value pairs.
138 using SurfaceAttributes = std::map<SurfaceAttributeKey, SurfaceAttributeValue>;
139 
140 struct SurfaceState {
141   int32_t surface_id;
142   int32_t process_id;
143   int32_t user_id;
144 
145   SurfaceAttributes surface_attributes;
146   SurfaceUpdateFlags update_flags;
147   std::vector<int32_t> queue_ids;
148 
149   // Convenience accessors.
GetVisibleSurfaceState150   bool GetVisible() const {
151     bool bool_value = false;
152     GetAttribute(SurfaceAttribute::Visible, &bool_value,
153                  ValidTypes<int32_t, int64_t, bool, float>{});
154     return bool_value;
155   }
156 
GetZOrderSurfaceState157   int GetZOrder() const {
158     int int_value = 0;
159     GetAttribute(SurfaceAttribute::ZOrder, &int_value,
160                  ValidTypes<int32_t, int64_t, float>{});
161     return int_value;
162   }
163 
164  private:
165   template <typename... Types>
166   struct ValidTypes {};
167 
168   template <typename ReturnType, typename... Types>
GetAttributeSurfaceState169   bool GetAttribute(SurfaceAttributeKey key, ReturnType* out_value,
170                     ValidTypes<Types...>) const {
171     auto search = surface_attributes.find(key);
172     if (search != surface_attributes.end())
173       return pdx::rpc::IfAnyOf<Types...>::Get(&search->second, out_value);
174     else
175       return false;
176   }
177 
178   PDX_SERIALIZABLE_MEMBERS(SurfaceState, surface_id, process_id,
179                            surface_attributes, update_flags, queue_ids);
180 };
181 
182 struct SurfaceInfo {
183   int surface_id;
184   bool visible;
185   int z_order;
186 
187  private:
188   PDX_SERIALIZABLE_MEMBERS(SurfaceInfo, surface_id, visible, z_order);
189 };
190 
191 enum class ConfigFileType : uint32_t {
192   kLensMetrics,
193   kDeviceMetrics,
194   kDeviceConfiguration
195 };
196 
197 struct DisplayProtocol {
198   // Service path.
199   static constexpr char kClientPath[] = "system/vr/display/client";
200 
201   // Op codes.
202   enum {
203     kOpGetMetrics = 0,
204     kOpGetConfigurationData,
205     kOpSetupGlobalBuffer,
206     kOpDeleteGlobalBuffer,
207     kOpGetGlobalBuffer,
208     kOpIsVrAppRunning,
209     kOpCreateSurface,
210     kOpGetSurfaceInfo,
211     kOpCreateQueue,
212     kOpSetAttributes,
213   };
214 
215   // Aliases.
216   using LocalChannelHandle = pdx::LocalChannelHandle;
217   using Void = pdx::rpc::Void;
218 
219   // Methods.
220   PDX_REMOTE_METHOD(GetMetrics, kOpGetMetrics, Metrics(Void));
221   PDX_REMOTE_METHOD(GetConfigurationData, kOpGetConfigurationData,
222                     std::string(ConfigFileType config_type));
223   PDX_REMOTE_METHOD(SetupGlobalBuffer, kOpSetupGlobalBuffer,
224                     LocalNativeBufferHandle(DvrGlobalBufferKey key, size_t size,
225                                             uint64_t usage));
226   PDX_REMOTE_METHOD(DeleteGlobalBuffer, kOpDeleteGlobalBuffer,
227                     void(DvrGlobalBufferKey key));
228   PDX_REMOTE_METHOD(GetGlobalBuffer, kOpGetGlobalBuffer,
229                     LocalNativeBufferHandle(DvrGlobalBufferKey key));
230   PDX_REMOTE_METHOD(IsVrAppRunning, kOpIsVrAppRunning, bool(Void));
231   PDX_REMOTE_METHOD(CreateSurface, kOpCreateSurface,
232                     SurfaceInfo(const SurfaceAttributes& attributes));
233   PDX_REMOTE_METHOD(GetSurfaceInfo, kOpGetSurfaceInfo, SurfaceInfo(Void));
234   PDX_REMOTE_METHOD(
235       CreateQueue, kOpCreateQueue,
236       LocalChannelHandle(const ProducerQueueConfig& producer_config));
237   PDX_REMOTE_METHOD(SetAttributes, kOpSetAttributes,
238                     void(const SurfaceAttributes& attributes));
239 };
240 
241 struct DisplayManagerProtocol {
242   // Service path.
243   static constexpr char kClientPath[] = "system/vr/display/manager";
244 
245   // Op codes.
246   enum {
247     kOpGetSurfaceState = 0,
248     kOpGetSurfaceQueue,
249   };
250 
251   // Aliases.
252   using LocalChannelHandle = pdx::LocalChannelHandle;
253   using Void = pdx::rpc::Void;
254 
255   // Methods.
256   PDX_REMOTE_METHOD(GetSurfaceState, kOpGetSurfaceState,
257                     std::vector<SurfaceState>(Void));
258   PDX_REMOTE_METHOD(GetSurfaceQueue, kOpGetSurfaceQueue,
259                     LocalChannelHandle(int surface_id, int queue_id));
260 };
261 
262 struct VSyncSchedInfo {
263   int64_t vsync_period_ns;
264   int64_t timestamp_ns;
265   uint32_t next_vsync_count;
266 
267  private:
268   PDX_SERIALIZABLE_MEMBERS(VSyncSchedInfo, vsync_period_ns, timestamp_ns,
269                            next_vsync_count);
270 };
271 
272 struct VSyncProtocol {
273   // Service path.
274   static constexpr char kClientPath[] = "system/vr/display/vsync";
275 
276   // Op codes.
277   enum {
278     kOpWait = 0,
279     kOpAck,
280     kOpGetLastTimestamp,
281     kOpGetSchedInfo,
282     kOpAcknowledge,
283   };
284 
285   // Aliases.
286   using Void = pdx::rpc::Void;
287   using Timestamp = int64_t;
288 
289   // Methods.
290   PDX_REMOTE_METHOD(Wait, kOpWait, Timestamp(Void));
291   PDX_REMOTE_METHOD(GetLastTimestamp, kOpGetLastTimestamp, Timestamp(Void));
292   PDX_REMOTE_METHOD(GetSchedInfo, kOpGetSchedInfo, VSyncSchedInfo(Void));
293   PDX_REMOTE_METHOD(Acknowledge, kOpAcknowledge, void(Void));
294 };
295 
296 }  // namespace display
297 }  // namespace dvr
298 }  // namespace android
299 
300 #endif  // ANDROID_DVR_DISPLAY_PROTOCOL_H_
301