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