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 #ifndef ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H 17 #define ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H 18 19 #include <android-base/unique_fd.h> 20 #include <android/frameworks/vr/composer/1.0/IVrComposerClient.h> 21 #include <android/hardware/graphics/composer/2.1/IComposer.h> 22 #include <composer-hal/2.1/ComposerHal.h> 23 #include <ui/Fence.h> 24 #include <ui/GraphicBuffer.h> 25 #include <utils/StrongPointer.h> 26 27 #include <mutex> 28 #include <unordered_map> 29 30 using namespace android::frameworks::vr::composer::V1_0; 31 using namespace android::hardware::graphics::common::V1_0; 32 using namespace android::hardware::graphics::composer::V2_1; 33 34 using android::hardware::hidl_handle; 35 using android::hardware::hidl_string; 36 using android::hardware::hidl_vec; 37 using android::hardware::Return; 38 using android::hardware::Void; 39 40 namespace android { 41 42 class Fence; 43 44 namespace dvr { 45 46 class VrComposerClient; 47 48 using android::hardware::graphics::common::V1_0::PixelFormat; 49 using android::hardware::graphics::composer::V2_1::hal::ComposerHal; 50 51 class ComposerView { 52 public: 53 struct ComposerLayer { 54 using Recti = hardware::graphics::composer::V2_1::IComposerClient::Rect; 55 using Rectf = hardware::graphics::composer::V2_1::IComposerClient::FRect; 56 using BlendMode = 57 hardware::graphics::composer::V2_1::IComposerClient::BlendMode; 58 59 Layer id; 60 sp<GraphicBuffer> buffer; 61 sp<Fence> fence; 62 Recti display_frame; 63 Rectf crop; 64 BlendMode blend_mode; 65 float alpha; 66 uint32_t type; 67 uint32_t app_id; 68 uint32_t z_order; 69 int32_t cursor_x; 70 int32_t cursor_y; 71 IComposerClient::Color color; 72 int32_t dataspace; 73 int32_t transform; 74 std::vector<hwc_rect_t> visible_regions; 75 std::vector<hwc_rect_t> damaged_regions; 76 }; 77 78 struct Frame { 79 Display display_id; 80 // This is set to true to notify the upper layer that the display is 81 // being removed, or left false in the case of a normal frame. The upper 82 // layer tracks display IDs and will handle new ones showing up. 83 bool removed = false; 84 int32_t display_width; 85 int32_t display_height; 86 Config active_config; 87 ColorMode color_mode; 88 IComposerClient::PowerMode power_mode; 89 IComposerClient::Vsync vsync_enabled; 90 float color_transform[16]; 91 int32_t color_transform_hint; 92 std::vector<ComposerLayer> layers; 93 }; 94 95 class Observer { 96 public: ~Observer()97 virtual ~Observer() {} 98 99 // Returns a list of layers that need to be shown together. Layers are 100 // returned in z-order, with the lowest layer first. 101 virtual base::unique_fd OnNewFrame(const Frame& frame) = 0; 102 }; 103 ~ComposerView()104 virtual ~ComposerView() {} 105 106 virtual void ForceDisplaysRefresh() = 0; 107 virtual void RegisterObserver(Observer* observer) = 0; 108 virtual void UnregisterObserver(Observer* observer) = 0; 109 }; 110 111 struct HwcLayer { 112 using Composition = 113 hardware::graphics::composer::V2_1::IComposerClient::Composition; 114 HwcLayerHwcLayer115 HwcLayer(Layer new_id) { 116 info.id = new_id; 117 } 118 119 void dumpDebugInfo(std::string* result) const; 120 121 Composition composition_type; 122 ComposerView::ComposerLayer info; 123 IVrComposerClient::BufferMetadata buffer_metadata; 124 }; 125 126 class HwcDisplay { 127 public: 128 HwcDisplay(int32_t width, int32_t height); 129 ~HwcDisplay(); 130 width()131 int32_t width() const { return width_; } height()132 int32_t height() const { return height_; } 133 134 HwcLayer* CreateLayer(); 135 bool DestroyLayer(Layer id); 136 HwcLayer* GetLayer(Layer id); 137 138 bool SetClientTarget(const native_handle_t* handle, base::unique_fd fence); 139 void SetClientTargetMetadata( 140 const IVrComposerClient::BufferMetadata& metadata); 141 142 void GetChangedCompositionTypes( 143 std::vector<Layer>* layer_ids, 144 std::vector<IComposerClient::Composition>* composition); 145 146 Error GetFrame(std::vector<ComposerView::ComposerLayer>* out_frame); 147 148 std::vector<Layer> UpdateLastFrameAndGetLastFrameLayers(); 149 active_config()150 Config active_config() const { return active_config_; } set_active_config(Config config)151 void set_active_config(Config config) { active_config_ = config; } 152 color_mode()153 ColorMode color_mode() const { return color_mode_; } set_color_mode(ColorMode mode)154 void set_color_mode(ColorMode mode) { color_mode_ = mode; } 155 power_mode()156 IComposerClient::PowerMode power_mode() const { return power_mode_; } set_power_mode(IComposerClient::PowerMode mode)157 void set_power_mode(IComposerClient::PowerMode mode) { power_mode_ = mode; } 158 vsync_enabled()159 IComposerClient::Vsync vsync_enabled() const { return vsync_enabled_; } set_vsync_enabled(IComposerClient::Vsync vsync)160 void set_vsync_enabled(IComposerClient::Vsync vsync) { 161 vsync_enabled_ = vsync; 162 } 163 color_transform()164 const float* color_transform() const { return color_transform_; } color_transform_hint()165 int32_t color_transform_hint() const { return color_transform_hint_; } 166 void SetColorTransform(const float* matrix, int32_t hint); 167 168 void dumpDebugInfo(std::string* result) const; 169 170 private: 171 // The client target buffer and the associated fence. 172 sp<GraphicBuffer> buffer_; 173 IVrComposerClient::BufferMetadata buffer_metadata_; 174 sp<Fence> fence_; 175 176 // List of currently active layers. 177 std::vector<HwcLayer> layers_; 178 179 std::vector<Layer> last_frame_layers_ids_; 180 181 // Layer ID generator. 182 uint64_t layer_ids_ = 1; 183 184 int32_t width_; 185 int32_t height_; 186 187 Config active_config_; 188 ColorMode color_mode_; 189 IComposerClient::PowerMode power_mode_; 190 IComposerClient::Vsync vsync_enabled_; 191 float color_transform_[16]; 192 int32_t color_transform_hint_; 193 194 HwcDisplay(const HwcDisplay&) = delete; 195 void operator=(const HwcDisplay&) = delete; 196 }; 197 198 class VrHwc : public IComposer, public ComposerHal, public ComposerView { 199 public: 200 VrHwc(); 201 ~VrHwc() override; 202 203 Error setLayerInfo(Display display, Layer layer, uint32_t type, 204 uint32_t appId); 205 Error setClientTargetMetadata( 206 Display display, const IVrComposerClient::BufferMetadata& metadata); 207 Error setLayerBufferMetadata( 208 Display display, Layer layer, 209 const IVrComposerClient::BufferMetadata& metadata); 210 211 // ComposerHal 212 bool hasCapability(hwc2_capability_t capability) override; 213 dumpDebugInfo()214 std::string dumpDebugInfo() override { return {}; } 215 void registerEventCallback(EventCallback* callback) override; 216 void unregisterEventCallback() override; 217 218 uint32_t getMaxVirtualDisplayCount() override; 219 Error createVirtualDisplay(uint32_t width, uint32_t height, 220 PixelFormat* format, Display* outDisplay) override; 221 Error destroyVirtualDisplay(Display display) override; 222 223 Error createLayer(Display display, Layer* outLayer) override; 224 Error destroyLayer(Display display, Layer layer) override; 225 226 Error getActiveConfig(Display display, Config* outConfig) override; 227 Error getClientTargetSupport(Display display, 228 uint32_t width, uint32_t height, 229 PixelFormat format, Dataspace dataspace) override; 230 Error getColorModes(Display display, hidl_vec<ColorMode>* outModes) override; 231 Error getDisplayAttribute(Display display, Config config, 232 IComposerClient::Attribute attribute, int32_t* outValue) override; 233 Error getDisplayConfigs(Display display, hidl_vec<Config>* outConfigs) override; 234 Error getDisplayName(Display display, hidl_string* outName) override; 235 Error getDisplayType(Display display, 236 IComposerClient::DisplayType* outType) override; 237 Error getDozeSupport(Display display, bool* outSupport) override; 238 Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes, 239 float* outMaxLuminance, float* outMaxAverageLuminance, 240 float* outMinLuminance) override; 241 242 Error setActiveConfig(Display display, Config config) override; 243 Error setColorMode(Display display, ColorMode mode) override; 244 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override; 245 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override; 246 247 Error setColorTransform(Display display, const float* matrix, 248 int32_t hint) override; 249 Error setClientTarget(Display display, buffer_handle_t target, 250 int32_t acquireFence, int32_t dataspace, 251 const std::vector<hwc_rect_t>& damage) override; 252 Error setOutputBuffer(Display display, buffer_handle_t buffer, 253 int32_t releaseFence) override; 254 Error validateDisplay(Display display, 255 std::vector<Layer>* outChangedLayers, 256 std::vector<IComposerClient::Composition>* outCompositionTypes, 257 uint32_t* outDisplayRequestMask, 258 std::vector<Layer>* outRequestedLayers, 259 std::vector<uint32_t>* outRequestMasks) override; 260 Error acceptDisplayChanges(Display display) override; 261 Error presentDisplay(Display display, int32_t* outPresentFence, 262 std::vector<Layer>* outLayers, 263 std::vector<int32_t>* outReleaseFences) override; 264 265 Error setLayerCursorPosition(Display display, Layer layer, 266 int32_t x, int32_t y) override; 267 Error setLayerBuffer(Display display, Layer layer, 268 buffer_handle_t buffer, int32_t acquireFence) override; 269 Error setLayerSurfaceDamage(Display display, Layer layer, 270 const std::vector<hwc_rect_t>& damage) override; 271 Error setLayerBlendMode(Display display, Layer layer, int32_t mode) override; 272 Error setLayerColor(Display display, Layer layer, 273 IComposerClient::Color color) override; 274 Error setLayerCompositionType(Display display, Layer layer, 275 int32_t type) override; 276 Error setLayerDataspace(Display display, Layer layer, 277 int32_t dataspace) override; 278 Error setLayerDisplayFrame(Display display, Layer layer, 279 const hwc_rect_t& frame) override; 280 Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override; 281 Error setLayerSidebandStream(Display display, Layer layer, 282 buffer_handle_t stream) override; 283 Error setLayerSourceCrop(Display display, Layer layer, 284 const hwc_frect_t& crop) override; 285 Error setLayerTransform(Display display, Layer layer, 286 int32_t transform) override; 287 Error setLayerVisibleRegion(Display display, Layer layer, 288 const std::vector<hwc_rect_t>& visible) override; 289 Error setLayerZOrder(Display display, Layer layer, uint32_t z) override; 290 291 // IComposer: 292 Return<void> getCapabilities(getCapabilities_cb hidl_cb) override; 293 Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override; 294 Return<void> createClient(createClient_cb hidl_cb) override; 295 296 // ComposerView: 297 void ForceDisplaysRefresh() override; 298 void RegisterObserver(Observer* observer) override; 299 void UnregisterObserver(Observer* observer) override; 300 301 private: 302 HwcDisplay* FindDisplay(Display display); 303 304 wp<VrComposerClient> client_; 305 306 // Guard access to internal state from binder threads. 307 std::mutex mutex_; 308 309 std::unordered_map<Display, std::unique_ptr<HwcDisplay>> displays_; 310 Display display_count_ = 2; 311 312 EventCallback* event_callback_ = nullptr; 313 Observer* observer_ = nullptr; 314 315 VrHwc(const VrHwc&) = delete; 316 void operator=(const VrHwc&) = delete; 317 }; 318 319 } // namespace dvr 320 } // namespace android 321 322 #endif // ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H 323