Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 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 | */ |
Daniel Nicoara | 4251e92 | 2017-04-13 15:19:15 -0400 | [diff] [blame] | 16 | #ifndef ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H |
| 17 | #define ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 18 | |
Daniel Nicoara | e13ec18 | 2017-02-22 12:22:41 -0500 | [diff] [blame] | 19 | #include <android-base/unique_fd.h> |
Daniel Nicoara | 1f42e3a | 2017-04-10 13:27:32 -0400 | [diff] [blame] | 20 | #include <android/frameworks/vr/composer/1.0/IVrComposerClient.h> |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 21 | #include <android/hardware/graphics/composer/2.1/IComposer.h> |
Chia-I Wu | d15d2d2 | 2018-01-29 13:59:18 -0800 | [diff] [blame] | 22 | #include <composer-hal/2.1/ComposerHal.h> |
Daniel Nicoara | 1c45710 | 2017-02-07 17:27:25 -0500 | [diff] [blame] | 23 | #include <ui/Fence.h> |
| 24 | #include <ui/GraphicBuffer.h> |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 25 | #include <utils/StrongPointer.h> |
| 26 | |
| 27 | #include <mutex> |
Albert Chaulk | 2b3b666 | 2017-03-06 13:24:51 -0500 | [diff] [blame] | 28 | #include <unordered_map> |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 29 | |
Daniel Nicoara | 1f42e3a | 2017-04-10 13:27:32 -0400 | [diff] [blame] | 30 | using namespace android::frameworks::vr::composer::V1_0; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 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; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 43 | |
| 44 | namespace dvr { |
| 45 | |
| 46 | class VrComposerClient; |
| 47 | |
| 48 | using android::hardware::graphics::common::V1_0::PixelFormat; |
Chia-I Wu | d15d2d2 | 2018-01-29 13:59:18 -0800 | [diff] [blame] | 49 | using android::hardware::graphics::composer::V2_1::hal::ComposerHal; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 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 | |
Daniel Nicoara | e13ec18 | 2017-02-22 12:22:41 -0500 | [diff] [blame] | 59 | Layer id; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 60 | sp<GraphicBuffer> buffer; |
| 61 | sp<Fence> fence; |
Alex Vakulenko | e4eec20 | 2017-01-27 14:41:04 -0800 | [diff] [blame] | 62 | Recti display_frame; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 63 | Rectf crop; |
| 64 | BlendMode blend_mode; |
Alex Vakulenko | e4eec20 | 2017-01-27 14:41:04 -0800 | [diff] [blame] | 65 | float alpha; |
| 66 | uint32_t type; |
| 67 | uint32_t app_id; |
Albert Chaulk | 730c89a | 2017-04-10 13:53:32 -0400 | [diff] [blame] | 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; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 76 | }; |
| 77 | |
Albert Chaulk | 2b3b666 | 2017-03-06 13:24:51 -0500 | [diff] [blame] | 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; |
Daniel Nicoara | d330a62 | 2017-03-28 11:48:42 -0400 | [diff] [blame] | 84 | int32_t display_width; |
| 85 | int32_t display_height; |
Albert Chaulk | 730c89a | 2017-04-10 13:53:32 -0400 | [diff] [blame] | 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; |
Albert Chaulk | 2b3b666 | 2017-03-06 13:24:51 -0500 | [diff] [blame] | 92 | std::vector<ComposerLayer> layers; |
| 93 | }; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 94 | |
| 95 | class Observer { |
| 96 | public: |
| 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. |
Daniel Nicoara | e13ec18 | 2017-02-22 12:22:41 -0500 | [diff] [blame] | 101 | virtual base::unique_fd OnNewFrame(const Frame& frame) = 0; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 102 | }; |
| 103 | |
| 104 | virtual ~ComposerView() {} |
| 105 | |
Daniel Nicoara | 8fc9822 | 2017-08-09 18:10:44 -0400 | [diff] [blame] | 106 | virtual void ForceDisplaysRefresh() = 0; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 107 | virtual void RegisterObserver(Observer* observer) = 0; |
| 108 | virtual void UnregisterObserver(Observer* observer) = 0; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 109 | }; |
| 110 | |
| 111 | struct HwcLayer { |
Alex Vakulenko | e4eec20 | 2017-01-27 14:41:04 -0800 | [diff] [blame] | 112 | using Composition = |
| 113 | hardware::graphics::composer::V2_1::IComposerClient::Composition; |
| 114 | |
Daniel Nicoara | e13ec18 | 2017-02-22 12:22:41 -0500 | [diff] [blame] | 115 | HwcLayer(Layer new_id) { |
| 116 | info.id = new_id; |
| 117 | } |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 118 | |
rongliu | 784ad68 | 2018-02-07 17:03:38 -0800 | [diff] [blame] | 119 | void dumpDebugInfo(std::string* result) const; |
| 120 | |
Alex Vakulenko | e4eec20 | 2017-01-27 14:41:04 -0800 | [diff] [blame] | 121 | Composition composition_type; |
Alex Vakulenko | e4eec20 | 2017-01-27 14:41:04 -0800 | [diff] [blame] | 122 | ComposerView::ComposerLayer info; |
Daniel Nicoara | 1f42e3a | 2017-04-10 13:27:32 -0400 | [diff] [blame] | 123 | IVrComposerClient::BufferMetadata buffer_metadata; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 124 | }; |
| 125 | |
| 126 | class HwcDisplay { |
| 127 | public: |
Daniel Nicoara | d330a62 | 2017-03-28 11:48:42 -0400 | [diff] [blame] | 128 | HwcDisplay(int32_t width, int32_t height); |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 129 | ~HwcDisplay(); |
| 130 | |
Daniel Nicoara | d330a62 | 2017-03-28 11:48:42 -0400 | [diff] [blame] | 131 | int32_t width() const { return width_; } |
| 132 | int32_t height() const { return height_; } |
| 133 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 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); |
Daniel Nicoara | 1f42e3a | 2017-04-10 13:27:32 -0400 | [diff] [blame] | 139 | void SetClientTargetMetadata( |
| 140 | const IVrComposerClient::BufferMetadata& metadata); |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 141 | |
| 142 | void GetChangedCompositionTypes( |
| 143 | std::vector<Layer>* layer_ids, |
| 144 | std::vector<IComposerClient::Composition>* composition); |
| 145 | |
Daniel Nicoara | e7916f8 | 2017-02-02 11:18:02 -0500 | [diff] [blame] | 146 | Error GetFrame(std::vector<ComposerView::ComposerLayer>* out_frame); |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 147 | |
Daniel Nicoara | e13ec18 | 2017-02-22 12:22:41 -0500 | [diff] [blame] | 148 | std::vector<Layer> UpdateLastFrameAndGetLastFrameLayers(); |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 149 | |
Albert Chaulk | 730c89a | 2017-04-10 13:53:32 -0400 | [diff] [blame] | 150 | Config active_config() const { return active_config_; } |
| 151 | void set_active_config(Config config) { active_config_ = config; } |
| 152 | |
| 153 | ColorMode color_mode() const { return color_mode_; } |
| 154 | void set_color_mode(ColorMode mode) { color_mode_ = mode; } |
| 155 | |
| 156 | IComposerClient::PowerMode power_mode() const { return power_mode_; } |
| 157 | void set_power_mode(IComposerClient::PowerMode mode) { power_mode_ = mode; } |
| 158 | |
| 159 | IComposerClient::Vsync vsync_enabled() const { return vsync_enabled_; } |
| 160 | void set_vsync_enabled(IComposerClient::Vsync vsync) { |
| 161 | vsync_enabled_ = vsync; |
| 162 | } |
| 163 | |
| 164 | const float* color_transform() const { return color_transform_; } |
| 165 | int32_t color_transform_hint() const { return color_transform_hint_; } |
| 166 | void SetColorTransform(const float* matrix, int32_t hint); |
| 167 | |
rongliu | 784ad68 | 2018-02-07 17:03:38 -0800 | [diff] [blame] | 168 | void dumpDebugInfo(std::string* result) const; |
| 169 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 170 | private: |
| 171 | // The client target buffer and the associated fence. |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 172 | sp<GraphicBuffer> buffer_; |
Daniel Nicoara | 1f42e3a | 2017-04-10 13:27:32 -0400 | [diff] [blame] | 173 | IVrComposerClient::BufferMetadata buffer_metadata_; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 174 | sp<Fence> fence_; |
| 175 | |
| 176 | // List of currently active layers. |
| 177 | std::vector<HwcLayer> layers_; |
| 178 | |
Daniel Nicoara | e13ec18 | 2017-02-22 12:22:41 -0500 | [diff] [blame] | 179 | std::vector<Layer> last_frame_layers_ids_; |
| 180 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 181 | // Layer ID generator. |
| 182 | uint64_t layer_ids_ = 1; |
| 183 | |
Daniel Nicoara | d330a62 | 2017-03-28 11:48:42 -0400 | [diff] [blame] | 184 | int32_t width_; |
| 185 | int32_t height_; |
| 186 | |
Albert Chaulk | 730c89a | 2017-04-10 13:53:32 -0400 | [diff] [blame] | 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 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 194 | HwcDisplay(const HwcDisplay&) = delete; |
| 195 | void operator=(const HwcDisplay&) = delete; |
| 196 | }; |
| 197 | |
Chia-I Wu | d15d2d2 | 2018-01-29 13:59:18 -0800 | [diff] [blame] | 198 | class VrHwc : public IComposer, public ComposerHal, public ComposerView { |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 199 | public: |
| 200 | VrHwc(); |
| 201 | ~VrHwc() override; |
| 202 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 203 | Error setLayerInfo(Display display, Layer layer, uint32_t type, |
| 204 | uint32_t appId); |
Daniel Nicoara | 1f42e3a | 2017-04-10 13:27:32 -0400 | [diff] [blame] | 205 | Error setClientTargetMetadata( |
| 206 | Display display, const IVrComposerClient::BufferMetadata& metadata); |
| 207 | Error setLayerBufferMetadata( |
| 208 | Display display, Layer layer, |
| 209 | const IVrComposerClient::BufferMetadata& metadata); |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 210 | |
Chia-I Wu | d15d2d2 | 2018-01-29 13:59:18 -0800 | [diff] [blame] | 211 | // ComposerHal |
Chia-I Wu | 41b98d4 | 2017-12-11 11:04:36 -0800 | [diff] [blame] | 212 | bool hasCapability(hwc2_capability_t capability) override; |
| 213 | |
Chia-I Wu | 513476a | 2018-01-31 09:30:01 -0800 | [diff] [blame] | 214 | std::string dumpDebugInfo() override { return {}; } |
| 215 | void registerEventCallback(EventCallback* callback) override; |
| 216 | void unregisterEventCallback() override {} |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 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: |
Daniel Nicoara | 8fc9822 | 2017-08-09 18:10:44 -0400 | [diff] [blame] | 297 | void ForceDisplaysRefresh() override; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 298 | void RegisterObserver(Observer* observer) override; |
| 299 | void UnregisterObserver(Observer* observer) override; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 300 | |
| 301 | private: |
Albert Chaulk | 2b3b666 | 2017-03-06 13:24:51 -0500 | [diff] [blame] | 302 | HwcDisplay* FindDisplay(Display display); |
| 303 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 304 | wp<VrComposerClient> client_; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 305 | |
| 306 | // Guard access to internal state from binder threads. |
| 307 | std::mutex mutex_; |
| 308 | |
Albert Chaulk | 2b3b666 | 2017-03-06 13:24:51 -0500 | [diff] [blame] | 309 | std::unordered_map<Display, std::unique_ptr<HwcDisplay>> displays_; |
Daniel Nicoara | a6cc422 | 2017-03-15 18:50:16 -0400 | [diff] [blame] | 310 | Display display_count_ = 2; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 311 | |
Chia-I Wu | 513476a | 2018-01-31 09:30:01 -0800 | [diff] [blame] | 312 | EventCallback* event_callback_ = nullptr; |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 313 | Observer* observer_ = nullptr; |
| 314 | |
| 315 | VrHwc(const VrHwc&) = delete; |
| 316 | void operator=(const VrHwc&) = delete; |
| 317 | }; |
| 318 | |
Daniel Nicoara | 51a0a56 | 2016-12-08 16:48:20 -0500 | [diff] [blame] | 319 | } // namespace dvr |
| 320 | } // namespace android |
| 321 | |
Daniel Nicoara | 4251e92 | 2017-04-13 15:19:15 -0400 | [diff] [blame] | 322 | #endif // ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H |