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