1 /*
2 * Copyright 2015 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
17 #include "hwc2on1adapter/HWC2On1Adapter.h"
18
19 //#define LOG_NDEBUG 0
20
21 #undef LOG_TAG
22 #define LOG_TAG "HWC2On1Adapter"
23 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
24
25
26 #include <inttypes.h>
27
28 #include <chrono>
29 #include <cstdlib>
30 #include <sstream>
31
32 #include <hardware/hwcomposer.h>
33 #include <log/log.h>
34 #include <utils/Trace.h>
35
36 using namespace std::chrono_literals;
37
getMinorVersion(struct hwc_composer_device_1 * device)38 static uint8_t getMinorVersion(struct hwc_composer_device_1* device)
39 {
40 auto version = device->common.version & HARDWARE_API_VERSION_2_MAJ_MIN_MASK;
41 return (version >> 16) & 0xF;
42 }
43
44 template <typename PFN, typename T>
asFP(T function)45 static hwc2_function_pointer_t asFP(T function)
46 {
47 static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
48 return reinterpret_cast<hwc2_function_pointer_t>(function);
49 }
50
51 using namespace HWC2;
52
53 static constexpr Attribute ColorMode = static_cast<Attribute>(6);
54
55 namespace android {
56
57 class HWC2On1Adapter::Callbacks : public hwc_procs_t {
58 public:
Callbacks(HWC2On1Adapter & adapter)59 explicit Callbacks(HWC2On1Adapter& adapter) : mAdapter(adapter) {
60 invalidate = &invalidateHook;
61 vsync = &vsyncHook;
62 hotplug = &hotplugHook;
63 }
64
invalidateHook(const hwc_procs_t * procs)65 static void invalidateHook(const hwc_procs_t* procs) {
66 auto callbacks = static_cast<const Callbacks*>(procs);
67 callbacks->mAdapter.hwc1Invalidate();
68 }
69
vsyncHook(const hwc_procs_t * procs,int display,int64_t timestamp)70 static void vsyncHook(const hwc_procs_t* procs, int display,
71 int64_t timestamp) {
72 auto callbacks = static_cast<const Callbacks*>(procs);
73 callbacks->mAdapter.hwc1Vsync(display, timestamp);
74 }
75
hotplugHook(const hwc_procs_t * procs,int display,int connected)76 static void hotplugHook(const hwc_procs_t* procs, int display,
77 int connected) {
78 auto callbacks = static_cast<const Callbacks*>(procs);
79 callbacks->mAdapter.hwc1Hotplug(display, connected);
80 }
81
82 private:
83 HWC2On1Adapter& mAdapter;
84 };
85
closeHook(hw_device_t *)86 static int closeHook(hw_device_t* /*device*/)
87 {
88 // Do nothing, since the real work is done in the class destructor, but we
89 // need to provide a valid function pointer for hwc2_close to call
90 return 0;
91 }
92
HWC2On1Adapter(hwc_composer_device_1_t * hwc1Device)93 HWC2On1Adapter::HWC2On1Adapter(hwc_composer_device_1_t* hwc1Device)
94 : mDumpString(),
95 mHwc1Device(hwc1Device),
96 mHwc1MinorVersion(getMinorVersion(hwc1Device)),
97 mHwc1SupportsVirtualDisplays(false),
98 mHwc1SupportsBackgroundColor(false),
99 mHwc1Callbacks(std::make_unique<Callbacks>(*this)),
100 mCapabilities(),
101 mLayers(),
102 mHwc1VirtualDisplay(),
103 mStateMutex(),
104 mCallbacks(),
105 mHasPendingInvalidate(false),
106 mPendingVsyncs(),
107 mPendingHotplugs(),
108 mDisplays(),
109 mHwc1DisplayMap()
110 {
111 common.close = closeHook;
112 getCapabilities = getCapabilitiesHook;
113 getFunction = getFunctionHook;
114 populateCapabilities();
115 populatePrimary();
116 mHwc1Device->registerProcs(mHwc1Device,
117 static_cast<const hwc_procs_t*>(mHwc1Callbacks.get()));
118 }
119
~HWC2On1Adapter()120 HWC2On1Adapter::~HWC2On1Adapter() {
121 hwc_close_1(mHwc1Device);
122 }
123
doGetCapabilities(uint32_t * outCount,int32_t * outCapabilities)124 void HWC2On1Adapter::doGetCapabilities(uint32_t* outCount,
125 int32_t* outCapabilities) {
126 if (outCapabilities == nullptr) {
127 *outCount = mCapabilities.size();
128 return;
129 }
130
131 auto capabilityIter = mCapabilities.cbegin();
132 for (size_t written = 0; written < *outCount; ++written) {
133 if (capabilityIter == mCapabilities.cend()) {
134 return;
135 }
136 outCapabilities[written] = static_cast<int32_t>(*capabilityIter);
137 ++capabilityIter;
138 }
139 }
140
doGetFunction(FunctionDescriptor descriptor)141 hwc2_function_pointer_t HWC2On1Adapter::doGetFunction(
142 FunctionDescriptor descriptor) {
143 switch (descriptor) {
144 // Device functions
145 case FunctionDescriptor::CreateVirtualDisplay:
146 return asFP<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
147 createVirtualDisplayHook);
148 case FunctionDescriptor::DestroyVirtualDisplay:
149 return asFP<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
150 destroyVirtualDisplayHook);
151 case FunctionDescriptor::Dump:
152 return asFP<HWC2_PFN_DUMP>(dumpHook);
153 case FunctionDescriptor::GetMaxVirtualDisplayCount:
154 return asFP<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
155 getMaxVirtualDisplayCountHook);
156 case FunctionDescriptor::RegisterCallback:
157 return asFP<HWC2_PFN_REGISTER_CALLBACK>(registerCallbackHook);
158
159 // Display functions
160 case FunctionDescriptor::AcceptDisplayChanges:
161 return asFP<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
162 displayHook<decltype(&Display::acceptChanges),
163 &Display::acceptChanges>);
164 case FunctionDescriptor::CreateLayer:
165 return asFP<HWC2_PFN_CREATE_LAYER>(
166 displayHook<decltype(&Display::createLayer),
167 &Display::createLayer, hwc2_layer_t*>);
168 case FunctionDescriptor::DestroyLayer:
169 return asFP<HWC2_PFN_DESTROY_LAYER>(
170 displayHook<decltype(&Display::destroyLayer),
171 &Display::destroyLayer, hwc2_layer_t>);
172 case FunctionDescriptor::GetActiveConfig:
173 return asFP<HWC2_PFN_GET_ACTIVE_CONFIG>(
174 displayHook<decltype(&Display::getActiveConfig),
175 &Display::getActiveConfig, hwc2_config_t*>);
176 case FunctionDescriptor::GetChangedCompositionTypes:
177 return asFP<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
178 displayHook<decltype(&Display::getChangedCompositionTypes),
179 &Display::getChangedCompositionTypes, uint32_t*,
180 hwc2_layer_t*, int32_t*>);
181 case FunctionDescriptor::GetColorModes:
182 return asFP<HWC2_PFN_GET_COLOR_MODES>(
183 displayHook<decltype(&Display::getColorModes),
184 &Display::getColorModes, uint32_t*, int32_t*>);
185 case FunctionDescriptor::GetDisplayAttribute:
186 return asFP<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
187 getDisplayAttributeHook);
188 case FunctionDescriptor::GetDisplayConfigs:
189 return asFP<HWC2_PFN_GET_DISPLAY_CONFIGS>(
190 displayHook<decltype(&Display::getConfigs),
191 &Display::getConfigs, uint32_t*, hwc2_config_t*>);
192 case FunctionDescriptor::GetDisplayName:
193 return asFP<HWC2_PFN_GET_DISPLAY_NAME>(
194 displayHook<decltype(&Display::getName),
195 &Display::getName, uint32_t*, char*>);
196 case FunctionDescriptor::GetDisplayRequests:
197 return asFP<HWC2_PFN_GET_DISPLAY_REQUESTS>(
198 displayHook<decltype(&Display::getRequests),
199 &Display::getRequests, int32_t*, uint32_t*, hwc2_layer_t*,
200 int32_t*>);
201 case FunctionDescriptor::GetDisplayType:
202 return asFP<HWC2_PFN_GET_DISPLAY_TYPE>(
203 displayHook<decltype(&Display::getType),
204 &Display::getType, int32_t*>);
205 case FunctionDescriptor::GetDozeSupport:
206 return asFP<HWC2_PFN_GET_DOZE_SUPPORT>(
207 displayHook<decltype(&Display::getDozeSupport),
208 &Display::getDozeSupport, int32_t*>);
209 case FunctionDescriptor::GetHdrCapabilities:
210 return asFP<HWC2_PFN_GET_HDR_CAPABILITIES>(
211 displayHook<decltype(&Display::getHdrCapabilities),
212 &Display::getHdrCapabilities, uint32_t*, int32_t*, float*,
213 float*, float*>);
214 case FunctionDescriptor::GetReleaseFences:
215 return asFP<HWC2_PFN_GET_RELEASE_FENCES>(
216 displayHook<decltype(&Display::getReleaseFences),
217 &Display::getReleaseFences, uint32_t*, hwc2_layer_t*,
218 int32_t*>);
219 case FunctionDescriptor::PresentDisplay:
220 return asFP<HWC2_PFN_PRESENT_DISPLAY>(
221 displayHook<decltype(&Display::present),
222 &Display::present, int32_t*>);
223 case FunctionDescriptor::SetActiveConfig:
224 return asFP<HWC2_PFN_SET_ACTIVE_CONFIG>(
225 displayHook<decltype(&Display::setActiveConfig),
226 &Display::setActiveConfig, hwc2_config_t>);
227 case FunctionDescriptor::SetClientTarget:
228 return asFP<HWC2_PFN_SET_CLIENT_TARGET>(
229 displayHook<decltype(&Display::setClientTarget),
230 &Display::setClientTarget, buffer_handle_t, int32_t,
231 int32_t, hwc_region_t>);
232 case FunctionDescriptor::SetColorMode:
233 return asFP<HWC2_PFN_SET_COLOR_MODE>(setColorModeHook);
234 case FunctionDescriptor::SetColorTransform:
235 return asFP<HWC2_PFN_SET_COLOR_TRANSFORM>(setColorTransformHook);
236 case FunctionDescriptor::SetOutputBuffer:
237 return asFP<HWC2_PFN_SET_OUTPUT_BUFFER>(
238 displayHook<decltype(&Display::setOutputBuffer),
239 &Display::setOutputBuffer, buffer_handle_t, int32_t>);
240 case FunctionDescriptor::SetPowerMode:
241 return asFP<HWC2_PFN_SET_POWER_MODE>(setPowerModeHook);
242 case FunctionDescriptor::SetVsyncEnabled:
243 return asFP<HWC2_PFN_SET_VSYNC_ENABLED>(setVsyncEnabledHook);
244 case FunctionDescriptor::ValidateDisplay:
245 return asFP<HWC2_PFN_VALIDATE_DISPLAY>(
246 displayHook<decltype(&Display::validate),
247 &Display::validate, uint32_t*, uint32_t*>);
248 case FunctionDescriptor::GetClientTargetSupport:
249 return asFP<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
250 displayHook<decltype(&Display::getClientTargetSupport),
251 &Display::getClientTargetSupport, uint32_t, uint32_t,
252 int32_t, int32_t>);
253
254 // Layer functions
255 case FunctionDescriptor::SetCursorPosition:
256 return asFP<HWC2_PFN_SET_CURSOR_POSITION>(
257 layerHook<decltype(&Layer::setCursorPosition),
258 &Layer::setCursorPosition, int32_t, int32_t>);
259 case FunctionDescriptor::SetLayerBuffer:
260 return asFP<HWC2_PFN_SET_LAYER_BUFFER>(
261 layerHook<decltype(&Layer::setBuffer), &Layer::setBuffer,
262 buffer_handle_t, int32_t>);
263 case FunctionDescriptor::SetLayerSurfaceDamage:
264 return asFP<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
265 layerHook<decltype(&Layer::setSurfaceDamage),
266 &Layer::setSurfaceDamage, hwc_region_t>);
267
268 // Layer state functions
269 case FunctionDescriptor::SetLayerBlendMode:
270 return asFP<HWC2_PFN_SET_LAYER_BLEND_MODE>(
271 setLayerBlendModeHook);
272 case FunctionDescriptor::SetLayerColor:
273 return asFP<HWC2_PFN_SET_LAYER_COLOR>(
274 layerHook<decltype(&Layer::setColor), &Layer::setColor,
275 hwc_color_t>);
276 case FunctionDescriptor::SetLayerCompositionType:
277 return asFP<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
278 setLayerCompositionTypeHook);
279 case FunctionDescriptor::SetLayerDataspace:
280 return asFP<HWC2_PFN_SET_LAYER_DATASPACE>(setLayerDataspaceHook);
281 case FunctionDescriptor::SetLayerDisplayFrame:
282 return asFP<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
283 layerHook<decltype(&Layer::setDisplayFrame),
284 &Layer::setDisplayFrame, hwc_rect_t>);
285 case FunctionDescriptor::SetLayerPlaneAlpha:
286 return asFP<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
287 layerHook<decltype(&Layer::setPlaneAlpha),
288 &Layer::setPlaneAlpha, float>);
289 case FunctionDescriptor::SetLayerSidebandStream:
290 return asFP<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(
291 layerHook<decltype(&Layer::setSidebandStream),
292 &Layer::setSidebandStream, const native_handle_t*>);
293 case FunctionDescriptor::SetLayerSourceCrop:
294 return asFP<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
295 layerHook<decltype(&Layer::setSourceCrop),
296 &Layer::setSourceCrop, hwc_frect_t>);
297 case FunctionDescriptor::SetLayerTransform:
298 return asFP<HWC2_PFN_SET_LAYER_TRANSFORM>(setLayerTransformHook);
299 case FunctionDescriptor::SetLayerVisibleRegion:
300 return asFP<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
301 layerHook<decltype(&Layer::setVisibleRegion),
302 &Layer::setVisibleRegion, hwc_region_t>);
303 case FunctionDescriptor::SetLayerZOrder:
304 return asFP<HWC2_PFN_SET_LAYER_Z_ORDER>(setLayerZOrderHook);
305
306 default:
307 ALOGE("doGetFunction: Unknown function descriptor: %d (%s)",
308 static_cast<int32_t>(descriptor),
309 to_string(descriptor).c_str());
310 return nullptr;
311 }
312 }
313
314 // Device functions
315
createVirtualDisplay(uint32_t width,uint32_t height,hwc2_display_t * outDisplay)316 Error HWC2On1Adapter::createVirtualDisplay(uint32_t width,
317 uint32_t height, hwc2_display_t* outDisplay) {
318 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
319
320 if (mHwc1VirtualDisplay) {
321 // We have already allocated our only HWC1 virtual display
322 ALOGE("createVirtualDisplay: HWC1 virtual display already allocated");
323 return Error::NoResources;
324 }
325
326 mHwc1VirtualDisplay = std::make_shared<HWC2On1Adapter::Display>(*this,
327 HWC2::DisplayType::Virtual);
328 mHwc1VirtualDisplay->populateConfigs(width, height);
329 const auto displayId = mHwc1VirtualDisplay->getId();
330 mHwc1DisplayMap[HWC_DISPLAY_VIRTUAL] = displayId;
331 mHwc1VirtualDisplay->setHwc1Id(HWC_DISPLAY_VIRTUAL);
332 mDisplays.emplace(displayId, mHwc1VirtualDisplay);
333 *outDisplay = displayId;
334
335 return Error::None;
336 }
337
destroyVirtualDisplay(hwc2_display_t displayId)338 Error HWC2On1Adapter::destroyVirtualDisplay(hwc2_display_t displayId) {
339 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
340
341 if (!mHwc1VirtualDisplay || (mHwc1VirtualDisplay->getId() != displayId)) {
342 return Error::BadDisplay;
343 }
344
345 mHwc1VirtualDisplay.reset();
346 mHwc1DisplayMap.erase(HWC_DISPLAY_VIRTUAL);
347 mDisplays.erase(displayId);
348
349 return Error::None;
350 }
351
dump(uint32_t * outSize,char * outBuffer)352 void HWC2On1Adapter::dump(uint32_t* outSize, char* outBuffer) {
353 if (outBuffer != nullptr) {
354 auto copiedBytes = mDumpString.copy(outBuffer, *outSize);
355 *outSize = static_cast<uint32_t>(copiedBytes);
356 return;
357 }
358
359 std::stringstream output;
360
361 output << "-- HWC2On1Adapter --\n";
362
363 output << "Adapting to a HWC 1." << static_cast<int>(mHwc1MinorVersion) <<
364 " device\n";
365
366 // Attempt to acquire the lock for 1 second, but proceed without the lock
367 // after that, so we can still get some information if we're deadlocked
368 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex,
369 std::defer_lock);
370 lock.try_lock_for(1s);
371
372 if (mCapabilities.empty()) {
373 output << "Capabilities: None\n";
374 } else {
375 output << "Capabilities:\n";
376 for (auto capability : mCapabilities) {
377 output << " " << to_string(capability) << '\n';
378 }
379 }
380
381 output << "Displays:\n";
382 for (const auto& element : mDisplays) {
383 const auto& display = element.second;
384 output << display->dump();
385 }
386 output << '\n';
387
388 // Release the lock before calling into HWC1, and since we no longer require
389 // mutual exclusion to access mCapabilities or mDisplays
390 lock.unlock();
391
392 if (mHwc1Device->dump) {
393 output << "HWC1 dump:\n";
394 std::vector<char> hwc1Dump(4096);
395 // Call with size - 1 to preserve a null character at the end
396 mHwc1Device->dump(mHwc1Device, hwc1Dump.data(),
397 static_cast<int>(hwc1Dump.size() - 1));
398 output << hwc1Dump.data();
399 }
400
401 mDumpString = output.str();
402 *outSize = static_cast<uint32_t>(mDumpString.size());
403 }
404
getMaxVirtualDisplayCount()405 uint32_t HWC2On1Adapter::getMaxVirtualDisplayCount() {
406 return mHwc1SupportsVirtualDisplays ? 1 : 0;
407 }
408
isValid(Callback descriptor)409 static bool isValid(Callback descriptor) {
410 switch (descriptor) {
411 case Callback::Hotplug: // Fall-through
412 case Callback::Refresh: // Fall-through
413 case Callback::Vsync: return true;
414 default: return false;
415 }
416 }
417
registerCallback(Callback descriptor,hwc2_callback_data_t callbackData,hwc2_function_pointer_t pointer)418 Error HWC2On1Adapter::registerCallback(Callback descriptor,
419 hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer) {
420 if (!isValid(descriptor)) {
421 return Error::BadParameter;
422 }
423
424 ALOGV("registerCallback(%s, %p, %p)", to_string(descriptor).c_str(),
425 callbackData, pointer);
426
427 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
428
429 mCallbacks[descriptor] = {callbackData, pointer};
430
431 bool hasPendingInvalidate = false;
432 std::vector<hwc2_display_t> displayIds;
433 std::vector<std::pair<hwc2_display_t, int64_t>> pendingVsyncs;
434 std::vector<std::pair<hwc2_display_t, int>> pendingHotplugs;
435
436 if (descriptor == Callback::Refresh) {
437 hasPendingInvalidate = mHasPendingInvalidate;
438 if (hasPendingInvalidate) {
439 for (auto& displayPair : mDisplays) {
440 displayIds.emplace_back(displayPair.first);
441 }
442 }
443 mHasPendingInvalidate = false;
444 } else if (descriptor == Callback::Vsync) {
445 for (auto pending : mPendingVsyncs) {
446 auto hwc1DisplayId = pending.first;
447 if (mHwc1DisplayMap.count(hwc1DisplayId) == 0) {
448 ALOGE("hwc1Vsync: Couldn't find display for HWC1 id %d",
449 hwc1DisplayId);
450 continue;
451 }
452 auto displayId = mHwc1DisplayMap[hwc1DisplayId];
453 auto timestamp = pending.second;
454 pendingVsyncs.emplace_back(displayId, timestamp);
455 }
456 mPendingVsyncs.clear();
457 } else if (descriptor == Callback::Hotplug) {
458 // Hotplug the primary display
459 pendingHotplugs.emplace_back(mHwc1DisplayMap[HWC_DISPLAY_PRIMARY],
460 static_cast<int32_t>(Connection::Connected));
461
462 for (auto pending : mPendingHotplugs) {
463 auto hwc1DisplayId = pending.first;
464 if (mHwc1DisplayMap.count(hwc1DisplayId) == 0) {
465 ALOGE("hwc1Hotplug: Couldn't find display for HWC1 id %d",
466 hwc1DisplayId);
467 continue;
468 }
469 auto displayId = mHwc1DisplayMap[hwc1DisplayId];
470 auto connected = pending.second;
471 pendingHotplugs.emplace_back(displayId, connected);
472 }
473 }
474
475 // Call pending callbacks without the state lock held
476 lock.unlock();
477
478 if (hasPendingInvalidate) {
479 auto refresh = reinterpret_cast<HWC2_PFN_REFRESH>(pointer);
480 for (auto displayId : displayIds) {
481 refresh(callbackData, displayId);
482 }
483 }
484 if (!pendingVsyncs.empty()) {
485 auto vsync = reinterpret_cast<HWC2_PFN_VSYNC>(pointer);
486 for (auto& pendingVsync : pendingVsyncs) {
487 vsync(callbackData, pendingVsync.first, pendingVsync.second);
488 }
489 }
490 if (!pendingHotplugs.empty()) {
491 auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(pointer);
492 for (auto& pendingHotplug : pendingHotplugs) {
493 hotplug(callbackData, pendingHotplug.first, pendingHotplug.second);
494 }
495 }
496 return Error::None;
497 }
498
499 // Display functions
500
501 std::atomic<hwc2_display_t> HWC2On1Adapter::Display::sNextId(1);
502
Display(HWC2On1Adapter & device,HWC2::DisplayType type)503 HWC2On1Adapter::Display::Display(HWC2On1Adapter& device, HWC2::DisplayType type)
504 : mId(sNextId++),
505 mDevice(device),
506 mStateMutex(),
507 mHwc1RequestedContents(nullptr),
508 mRetireFence(),
509 mChanges(),
510 mHwc1Id(-1),
511 mConfigs(),
512 mActiveConfig(nullptr),
513 mActiveColorMode(static_cast<android_color_mode_t>(-1)),
514 mName(),
515 mType(type),
516 mPowerMode(PowerMode::Off),
517 mVsyncEnabled(Vsync::Invalid),
518 mClientTarget(),
519 mOutputBuffer(),
520 mHasColorTransform(false),
521 mLayers(),
522 mHwc1LayerMap(),
523 mNumAvailableRects(0),
524 mNextAvailableRect(nullptr),
525 mGeometryChanged(false)
526 {}
527
acceptChanges()528 Error HWC2On1Adapter::Display::acceptChanges() {
529 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
530
531 if (!mChanges) {
532 ALOGV("[%" PRIu64 "] acceptChanges failed, not validated", mId);
533 return Error::NotValidated;
534 }
535
536 ALOGV("[%" PRIu64 "] acceptChanges", mId);
537
538 for (auto& change : mChanges->getTypeChanges()) {
539 auto layerId = change.first;
540 auto type = change.second;
541 if (mDevice.mLayers.count(layerId) == 0) {
542 // This should never happen but somehow does.
543 ALOGW("Cannot accept change for unknown layer (%" PRIu64 ")",
544 layerId);
545 continue;
546 }
547 auto layer = mDevice.mLayers[layerId];
548 layer->setCompositionType(type);
549 }
550
551 mChanges->clearTypeChanges();
552
553 return Error::None;
554 }
555
createLayer(hwc2_layer_t * outLayerId)556 Error HWC2On1Adapter::Display::createLayer(hwc2_layer_t* outLayerId) {
557 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
558
559 auto layer = *mLayers.emplace(std::make_shared<Layer>(*this));
560 mDevice.mLayers.emplace(std::make_pair(layer->getId(), layer));
561 *outLayerId = layer->getId();
562 ALOGV("[%" PRIu64 "] created layer %" PRIu64, mId, *outLayerId);
563 markGeometryChanged();
564 return Error::None;
565 }
566
destroyLayer(hwc2_layer_t layerId)567 Error HWC2On1Adapter::Display::destroyLayer(hwc2_layer_t layerId) {
568 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
569
570 const auto mapLayer = mDevice.mLayers.find(layerId);
571 if (mapLayer == mDevice.mLayers.end()) {
572 ALOGV("[%" PRIu64 "] destroyLayer(%" PRIu64 ") failed: no such layer",
573 mId, layerId);
574 return Error::BadLayer;
575 }
576 const auto layer = mapLayer->second;
577 mDevice.mLayers.erase(mapLayer);
578 const auto zRange = mLayers.equal_range(layer);
579 for (auto current = zRange.first; current != zRange.second; ++current) {
580 if (**current == *layer) {
581 current = mLayers.erase(current);
582 break;
583 }
584 }
585 ALOGV("[%" PRIu64 "] destroyed layer %" PRIu64, mId, layerId);
586 markGeometryChanged();
587 return Error::None;
588 }
589
getActiveConfig(hwc2_config_t * outConfig)590 Error HWC2On1Adapter::Display::getActiveConfig(hwc2_config_t* outConfig) {
591 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
592
593 if (!mActiveConfig) {
594 ALOGV("[%" PRIu64 "] getActiveConfig --> %s", mId,
595 to_string(Error::BadConfig).c_str());
596 return Error::BadConfig;
597 }
598 auto configId = mActiveConfig->getId();
599 ALOGV("[%" PRIu64 "] getActiveConfig --> %u", mId, configId);
600 *outConfig = configId;
601 return Error::None;
602 }
603
getAttribute(hwc2_config_t configId,Attribute attribute,int32_t * outValue)604 Error HWC2On1Adapter::Display::getAttribute(hwc2_config_t configId,
605 Attribute attribute, int32_t* outValue) {
606 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
607
608 if (configId > mConfigs.size() || !mConfigs[configId]->isOnDisplay(*this)) {
609 ALOGV("[%" PRIu64 "] getAttribute failed: bad config (%u)", mId,
610 configId);
611 return Error::BadConfig;
612 }
613 *outValue = mConfigs[configId]->getAttribute(attribute);
614 ALOGV("[%" PRIu64 "] getAttribute(%u, %s) --> %d", mId, configId,
615 to_string(attribute).c_str(), *outValue);
616 return Error::None;
617 }
618
getChangedCompositionTypes(uint32_t * outNumElements,hwc2_layer_t * outLayers,int32_t * outTypes)619 Error HWC2On1Adapter::Display::getChangedCompositionTypes(
620 uint32_t* outNumElements, hwc2_layer_t* outLayers, int32_t* outTypes) {
621 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
622
623 if (!mChanges) {
624 ALOGE("[%" PRIu64 "] getChangedCompositionTypes failed: not validated",
625 mId);
626 return Error::NotValidated;
627 }
628
629 if ((outLayers == nullptr) || (outTypes == nullptr)) {
630 *outNumElements = mChanges->getTypeChanges().size();
631 return Error::None;
632 }
633
634 uint32_t numWritten = 0;
635 for (const auto& element : mChanges->getTypeChanges()) {
636 if (numWritten == *outNumElements) {
637 break;
638 }
639 auto layerId = element.first;
640 auto intType = static_cast<int32_t>(element.second);
641 ALOGV("Adding %" PRIu64 " %s", layerId,
642 to_string(element.second).c_str());
643 outLayers[numWritten] = layerId;
644 outTypes[numWritten] = intType;
645 ++numWritten;
646 }
647 *outNumElements = numWritten;
648
649 return Error::None;
650 }
651
getColorModes(uint32_t * outNumModes,int32_t * outModes)652 Error HWC2On1Adapter::Display::getColorModes(uint32_t* outNumModes,
653 int32_t* outModes) {
654 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
655
656 if (!outModes) {
657 *outNumModes = mColorModes.size();
658 return Error::None;
659 }
660 uint32_t numModes = std::min(*outNumModes,
661 static_cast<uint32_t>(mColorModes.size()));
662 std::copy_n(mColorModes.cbegin(), numModes, outModes);
663 *outNumModes = numModes;
664 return Error::None;
665 }
666
getConfigs(uint32_t * outNumConfigs,hwc2_config_t * outConfigs)667 Error HWC2On1Adapter::Display::getConfigs(uint32_t* outNumConfigs,
668 hwc2_config_t* outConfigs) {
669 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
670
671 if (!outConfigs) {
672 *outNumConfigs = mConfigs.size();
673 return Error::None;
674 }
675 uint32_t numWritten = 0;
676 for (const auto& config : mConfigs) {
677 if (numWritten == *outNumConfigs) {
678 break;
679 }
680 outConfigs[numWritten] = config->getId();
681 ++numWritten;
682 }
683 *outNumConfigs = numWritten;
684 return Error::None;
685 }
686
getDozeSupport(int32_t * outSupport)687 Error HWC2On1Adapter::Display::getDozeSupport(int32_t* outSupport) {
688 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
689
690 if (mDevice.mHwc1MinorVersion < 4 || mHwc1Id != 0) {
691 *outSupport = 0;
692 } else {
693 *outSupport = 1;
694 }
695 return Error::None;
696 }
697
getHdrCapabilities(uint32_t * outNumTypes,int32_t *,float *,float *,float *)698 Error HWC2On1Adapter::Display::getHdrCapabilities(uint32_t* outNumTypes,
699 int32_t* /*outTypes*/, float* /*outMaxLuminance*/,
700 float* /*outMaxAverageLuminance*/, float* /*outMinLuminance*/) {
701 // This isn't supported on HWC1, so per the HWC2 header, return numTypes = 0
702 *outNumTypes = 0;
703 return Error::None;
704 }
705
getName(uint32_t * outSize,char * outName)706 Error HWC2On1Adapter::Display::getName(uint32_t* outSize, char* outName) {
707 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
708
709 if (!outName) {
710 *outSize = mName.size();
711 return Error::None;
712 }
713 auto numCopied = mName.copy(outName, *outSize);
714 *outSize = numCopied;
715 return Error::None;
716 }
717
getReleaseFences(uint32_t * outNumElements,hwc2_layer_t * outLayers,int32_t * outFences)718 Error HWC2On1Adapter::Display::getReleaseFences(uint32_t* outNumElements,
719 hwc2_layer_t* outLayers, int32_t* outFences) {
720 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
721
722 uint32_t numWritten = 0;
723 bool outputsNonNull = (outLayers != nullptr) && (outFences != nullptr);
724 for (const auto& layer : mLayers) {
725 if (outputsNonNull && (numWritten == *outNumElements)) {
726 break;
727 }
728
729 auto releaseFence = layer->getReleaseFence();
730 if (releaseFence != MiniFence::NO_FENCE) {
731 if (outputsNonNull) {
732 outLayers[numWritten] = layer->getId();
733 outFences[numWritten] = releaseFence->dup();
734 }
735 ++numWritten;
736 }
737 }
738 *outNumElements = numWritten;
739
740 return Error::None;
741 }
742
getRequests(int32_t * outDisplayRequests,uint32_t * outNumElements,hwc2_layer_t * outLayers,int32_t * outLayerRequests)743 Error HWC2On1Adapter::Display::getRequests(int32_t* outDisplayRequests,
744 uint32_t* outNumElements, hwc2_layer_t* outLayers,
745 int32_t* outLayerRequests) {
746 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
747
748 if (!mChanges) {
749 return Error::NotValidated;
750 }
751
752 if (outLayers == nullptr || outLayerRequests == nullptr) {
753 *outNumElements = mChanges->getNumLayerRequests();
754 return Error::None;
755 }
756
757 // Display requests (HWC2::DisplayRequest) are not supported by hwc1:
758 // A hwc1 has always zero requests for the client.
759 *outDisplayRequests = 0;
760
761 uint32_t numWritten = 0;
762 for (const auto& request : mChanges->getLayerRequests()) {
763 if (numWritten == *outNumElements) {
764 break;
765 }
766 outLayers[numWritten] = request.first;
767 outLayerRequests[numWritten] = static_cast<int32_t>(request.second);
768 ++numWritten;
769 }
770
771 return Error::None;
772 }
773
getType(int32_t * outType)774 Error HWC2On1Adapter::Display::getType(int32_t* outType) {
775 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
776
777 *outType = static_cast<int32_t>(mType);
778 return Error::None;
779 }
780
present(int32_t * outRetireFence)781 Error HWC2On1Adapter::Display::present(int32_t* outRetireFence) {
782 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
783
784 if (mChanges) {
785 Error error = mDevice.setAllDisplays();
786 if (error != Error::None) {
787 ALOGE("[%" PRIu64 "] present: setAllDisplaysFailed (%s)", mId,
788 to_string(error).c_str());
789 return error;
790 }
791 }
792
793 *outRetireFence = mRetireFence.get()->dup();
794 ALOGV("[%" PRIu64 "] present returning retire fence %d", mId,
795 *outRetireFence);
796
797 return Error::None;
798 }
799
setActiveConfig(hwc2_config_t configId)800 Error HWC2On1Adapter::Display::setActiveConfig(hwc2_config_t configId) {
801 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
802
803 auto config = getConfig(configId);
804 if (!config) {
805 return Error::BadConfig;
806 }
807 if (config == mActiveConfig) {
808 return Error::None;
809 }
810
811 if (mDevice.mHwc1MinorVersion >= 4) {
812 uint32_t hwc1Id = 0;
813 auto error = config->getHwc1IdForColorMode(mActiveColorMode, &hwc1Id);
814 if (error != Error::None) {
815 return error;
816 }
817
818 int intError = mDevice.mHwc1Device->setActiveConfig(mDevice.mHwc1Device,
819 mHwc1Id, static_cast<int>(hwc1Id));
820 if (intError != 0) {
821 ALOGE("setActiveConfig: Failed to set active config on HWC1 (%d)",
822 intError);
823 return Error::BadConfig;
824 }
825 mActiveConfig = config;
826 }
827
828 return Error::None;
829 }
830
setClientTarget(buffer_handle_t target,int32_t acquireFence,int32_t,hwc_region_t)831 Error HWC2On1Adapter::Display::setClientTarget(buffer_handle_t target,
832 int32_t acquireFence, int32_t /*dataspace*/, hwc_region_t /*damage*/) {
833 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
834
835 ALOGV("[%" PRIu64 "] setClientTarget(%p, %d)", mId, target, acquireFence);
836 mClientTarget.setBuffer(target);
837 mClientTarget.setFence(acquireFence);
838 // dataspace and damage can't be used by HWC1, so ignore them
839 return Error::None;
840 }
841
setColorMode(android_color_mode_t mode)842 Error HWC2On1Adapter::Display::setColorMode(android_color_mode_t mode) {
843 std::unique_lock<std::recursive_mutex> lock (mStateMutex);
844
845 ALOGV("[%" PRIu64 "] setColorMode(%d)", mId, mode);
846
847 if (mode == mActiveColorMode) {
848 return Error::None;
849 }
850 if (mColorModes.count(mode) == 0) {
851 ALOGE("[%" PRIu64 "] Mode %d not found in mColorModes", mId, mode);
852 return Error::Unsupported;
853 }
854
855 uint32_t hwc1Config = 0;
856 auto error = mActiveConfig->getHwc1IdForColorMode(mode, &hwc1Config);
857 if (error != Error::None) {
858 return error;
859 }
860
861 ALOGV("[%" PRIu64 "] Setting HWC1 config %u", mId, hwc1Config);
862 int intError = mDevice.mHwc1Device->setActiveConfig(mDevice.mHwc1Device,
863 mHwc1Id, hwc1Config);
864 if (intError != 0) {
865 ALOGE("[%" PRIu64 "] Failed to set HWC1 config (%d)", mId, intError);
866 return Error::Unsupported;
867 }
868
869 mActiveColorMode = mode;
870 return Error::None;
871 }
872
setColorTransform(android_color_transform_t hint)873 Error HWC2On1Adapter::Display::setColorTransform(android_color_transform_t hint) {
874 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
875
876 ALOGV("%" PRIu64 "] setColorTransform(%d)", mId,
877 static_cast<int32_t>(hint));
878 mHasColorTransform = (hint != HAL_COLOR_TRANSFORM_IDENTITY);
879 return Error::None;
880 }
881
setOutputBuffer(buffer_handle_t buffer,int32_t releaseFence)882 Error HWC2On1Adapter::Display::setOutputBuffer(buffer_handle_t buffer,
883 int32_t releaseFence) {
884 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
885
886 ALOGV("[%" PRIu64 "] setOutputBuffer(%p, %d)", mId, buffer, releaseFence);
887 mOutputBuffer.setBuffer(buffer);
888 mOutputBuffer.setFence(releaseFence);
889 return Error::None;
890 }
891
isValid(PowerMode mode)892 static bool isValid(PowerMode mode) {
893 switch (mode) {
894 case PowerMode::Off: // Fall-through
895 case PowerMode::DozeSuspend: // Fall-through
896 case PowerMode::Doze: // Fall-through
897 case PowerMode::On: return true;
898 }
899 }
900
getHwc1PowerMode(PowerMode mode)901 static int getHwc1PowerMode(PowerMode mode) {
902 switch (mode) {
903 case PowerMode::Off: return HWC_POWER_MODE_OFF;
904 case PowerMode::DozeSuspend: return HWC_POWER_MODE_DOZE_SUSPEND;
905 case PowerMode::Doze: return HWC_POWER_MODE_DOZE;
906 case PowerMode::On: return HWC_POWER_MODE_NORMAL;
907 }
908 }
909
setPowerMode(PowerMode mode)910 Error HWC2On1Adapter::Display::setPowerMode(PowerMode mode) {
911 if (!isValid(mode)) {
912 return Error::BadParameter;
913 }
914 if (mode == mPowerMode) {
915 return Error::None;
916 }
917
918 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
919
920 int error = 0;
921 if (mDevice.mHwc1MinorVersion < 4) {
922 error = mDevice.mHwc1Device->blank(mDevice.mHwc1Device, mHwc1Id,
923 mode == PowerMode::Off);
924 } else {
925 error = mDevice.mHwc1Device->setPowerMode(mDevice.mHwc1Device,
926 mHwc1Id, getHwc1PowerMode(mode));
927 }
928 ALOGE_IF(error != 0, "setPowerMode: Failed to set power mode on HWC1 (%d)",
929 error);
930
931 ALOGV("[%" PRIu64 "] setPowerMode(%s)", mId, to_string(mode).c_str());
932 mPowerMode = mode;
933 return Error::None;
934 }
935
isValid(Vsync enable)936 static bool isValid(Vsync enable) {
937 switch (enable) {
938 case Vsync::Enable: // Fall-through
939 case Vsync::Disable: return true;
940 case Vsync::Invalid: return false;
941 }
942 }
943
setVsyncEnabled(Vsync enable)944 Error HWC2On1Adapter::Display::setVsyncEnabled(Vsync enable) {
945 if (!isValid(enable)) {
946 return Error::BadParameter;
947 }
948 if (enable == mVsyncEnabled) {
949 return Error::None;
950 }
951
952 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
953
954 int error = mDevice.mHwc1Device->eventControl(mDevice.mHwc1Device,
955 mHwc1Id, HWC_EVENT_VSYNC, enable == Vsync::Enable);
956 ALOGE_IF(error != 0, "setVsyncEnabled: Failed to set vsync on HWC1 (%d)",
957 error);
958
959 mVsyncEnabled = enable;
960 return Error::None;
961 }
962
validate(uint32_t * outNumTypes,uint32_t * outNumRequests)963 Error HWC2On1Adapter::Display::validate(uint32_t* outNumTypes,
964 uint32_t* outNumRequests) {
965 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
966
967 if (!mChanges) {
968 if (!mDevice.prepareAllDisplays()) {
969 return Error::BadDisplay;
970 }
971 } else {
972 ALOGE("Validate was called more than once!");
973 }
974
975 *outNumTypes = mChanges->getNumTypes();
976 *outNumRequests = mChanges->getNumLayerRequests();
977 ALOGV("[%" PRIu64 "] validate --> %u types, %u requests", mId, *outNumTypes,
978 *outNumRequests);
979 for (auto request : mChanges->getTypeChanges()) {
980 ALOGV("Layer %" PRIu64 " --> %s", request.first,
981 to_string(request.second).c_str());
982 }
983 return *outNumTypes > 0 ? Error::HasChanges : Error::None;
984 }
985
updateLayerZ(hwc2_layer_t layerId,uint32_t z)986 Error HWC2On1Adapter::Display::updateLayerZ(hwc2_layer_t layerId, uint32_t z) {
987 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
988
989 const auto mapLayer = mDevice.mLayers.find(layerId);
990 if (mapLayer == mDevice.mLayers.end()) {
991 ALOGE("[%" PRIu64 "] updateLayerZ failed to find layer", mId);
992 return Error::BadLayer;
993 }
994
995 const auto layer = mapLayer->second;
996 const auto zRange = mLayers.equal_range(layer);
997 bool layerOnDisplay = false;
998 for (auto current = zRange.first; current != zRange.second; ++current) {
999 if (**current == *layer) {
1000 if ((*current)->getZ() == z) {
1001 // Don't change anything if the Z hasn't changed
1002 return Error::None;
1003 }
1004 current = mLayers.erase(current);
1005 layerOnDisplay = true;
1006 break;
1007 }
1008 }
1009
1010 if (!layerOnDisplay) {
1011 ALOGE("[%" PRIu64 "] updateLayerZ failed to find layer on display",
1012 mId);
1013 return Error::BadLayer;
1014 }
1015
1016 layer->setZ(z);
1017 mLayers.emplace(std::move(layer));
1018 markGeometryChanged();
1019
1020 return Error::None;
1021 }
1022
getClientTargetSupport(uint32_t width,uint32_t height,int32_t format,int32_t dataspace)1023 Error HWC2On1Adapter::Display::getClientTargetSupport(uint32_t width, uint32_t height,
1024 int32_t format, int32_t dataspace){
1025 if (mActiveConfig == nullptr) {
1026 return Error::Unsupported;
1027 }
1028
1029 if (width == mActiveConfig->getAttribute(Attribute::Width) &&
1030 height == mActiveConfig->getAttribute(Attribute::Height) &&
1031 format == HAL_PIXEL_FORMAT_RGBA_8888 &&
1032 dataspace == HAL_DATASPACE_UNKNOWN) {
1033 return Error::None;
1034 }
1035
1036 return Error::Unsupported;
1037 }
1038
1039 static constexpr uint32_t ATTRIBUTES_WITH_COLOR[] = {
1040 HWC_DISPLAY_VSYNC_PERIOD,
1041 HWC_DISPLAY_WIDTH,
1042 HWC_DISPLAY_HEIGHT,
1043 HWC_DISPLAY_DPI_X,
1044 HWC_DISPLAY_DPI_Y,
1045 HWC_DISPLAY_COLOR_TRANSFORM,
1046 HWC_DISPLAY_NO_ATTRIBUTE,
1047 };
1048
1049 static constexpr uint32_t ATTRIBUTES_WITHOUT_COLOR[] = {
1050 HWC_DISPLAY_VSYNC_PERIOD,
1051 HWC_DISPLAY_WIDTH,
1052 HWC_DISPLAY_HEIGHT,
1053 HWC_DISPLAY_DPI_X,
1054 HWC_DISPLAY_DPI_Y,
1055 HWC_DISPLAY_NO_ATTRIBUTE,
1056 };
1057
1058 static constexpr size_t NUM_ATTRIBUTES_WITH_COLOR =
1059 sizeof(ATTRIBUTES_WITH_COLOR) / sizeof(uint32_t);
1060 static_assert(sizeof(ATTRIBUTES_WITH_COLOR) > sizeof(ATTRIBUTES_WITHOUT_COLOR),
1061 "Attribute tables have unexpected sizes");
1062
1063 static constexpr uint32_t ATTRIBUTE_MAP_WITH_COLOR[] = {
1064 6, // HWC_DISPLAY_NO_ATTRIBUTE = 0
1065 0, // HWC_DISPLAY_VSYNC_PERIOD = 1,
1066 1, // HWC_DISPLAY_WIDTH = 2,
1067 2, // HWC_DISPLAY_HEIGHT = 3,
1068 3, // HWC_DISPLAY_DPI_X = 4,
1069 4, // HWC_DISPLAY_DPI_Y = 5,
1070 5, // HWC_DISPLAY_COLOR_TRANSFORM = 6,
1071 };
1072
1073 static constexpr uint32_t ATTRIBUTE_MAP_WITHOUT_COLOR[] = {
1074 5, // HWC_DISPLAY_NO_ATTRIBUTE = 0
1075 0, // HWC_DISPLAY_VSYNC_PERIOD = 1,
1076 1, // HWC_DISPLAY_WIDTH = 2,
1077 2, // HWC_DISPLAY_HEIGHT = 3,
1078 3, // HWC_DISPLAY_DPI_X = 4,
1079 4, // HWC_DISPLAY_DPI_Y = 5,
1080 };
1081
1082 template <uint32_t attribute>
attributesMatch()1083 static constexpr bool attributesMatch()
1084 {
1085 bool match = (attribute ==
1086 ATTRIBUTES_WITH_COLOR[ATTRIBUTE_MAP_WITH_COLOR[attribute]]);
1087 if (attribute == HWC_DISPLAY_COLOR_TRANSFORM) {
1088 return match;
1089 }
1090
1091 return match && (attribute ==
1092 ATTRIBUTES_WITHOUT_COLOR[ATTRIBUTE_MAP_WITHOUT_COLOR[attribute]]);
1093 }
1094 static_assert(attributesMatch<HWC_DISPLAY_VSYNC_PERIOD>(),
1095 "Tables out of sync");
1096 static_assert(attributesMatch<HWC_DISPLAY_WIDTH>(), "Tables out of sync");
1097 static_assert(attributesMatch<HWC_DISPLAY_HEIGHT>(), "Tables out of sync");
1098 static_assert(attributesMatch<HWC_DISPLAY_DPI_X>(), "Tables out of sync");
1099 static_assert(attributesMatch<HWC_DISPLAY_DPI_Y>(), "Tables out of sync");
1100 static_assert(attributesMatch<HWC_DISPLAY_COLOR_TRANSFORM>(),
1101 "Tables out of sync");
1102
populateConfigs()1103 void HWC2On1Adapter::Display::populateConfigs() {
1104 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1105
1106 ALOGV("[%" PRIu64 "] populateConfigs", mId);
1107
1108 if (mHwc1Id == -1) {
1109 ALOGE("populateConfigs: HWC1 ID not set");
1110 return;
1111 }
1112
1113 const size_t MAX_NUM_CONFIGS = 128;
1114 uint32_t configs[MAX_NUM_CONFIGS] = {};
1115 size_t numConfigs = MAX_NUM_CONFIGS;
1116 mDevice.mHwc1Device->getDisplayConfigs(mDevice.mHwc1Device, mHwc1Id,
1117 configs, &numConfigs);
1118
1119 for (size_t c = 0; c < numConfigs; ++c) {
1120 uint32_t hwc1ConfigId = configs[c];
1121 auto newConfig = std::make_shared<Config>(*this);
1122
1123 int32_t values[NUM_ATTRIBUTES_WITH_COLOR] = {};
1124 bool hasColor = true;
1125 auto result = mDevice.mHwc1Device->getDisplayAttributes(
1126 mDevice.mHwc1Device, mHwc1Id, hwc1ConfigId,
1127 ATTRIBUTES_WITH_COLOR, values);
1128 if (result != 0) {
1129 mDevice.mHwc1Device->getDisplayAttributes(mDevice.mHwc1Device,
1130 mHwc1Id, hwc1ConfigId, ATTRIBUTES_WITHOUT_COLOR, values);
1131 hasColor = false;
1132 }
1133
1134 auto attributeMap = hasColor ?
1135 ATTRIBUTE_MAP_WITH_COLOR : ATTRIBUTE_MAP_WITHOUT_COLOR;
1136
1137 newConfig->setAttribute(Attribute::VsyncPeriod,
1138 values[attributeMap[HWC_DISPLAY_VSYNC_PERIOD]]);
1139 newConfig->setAttribute(Attribute::Width,
1140 values[attributeMap[HWC_DISPLAY_WIDTH]]);
1141 newConfig->setAttribute(Attribute::Height,
1142 values[attributeMap[HWC_DISPLAY_HEIGHT]]);
1143 newConfig->setAttribute(Attribute::DpiX,
1144 values[attributeMap[HWC_DISPLAY_DPI_X]]);
1145 newConfig->setAttribute(Attribute::DpiY,
1146 values[attributeMap[HWC_DISPLAY_DPI_Y]]);
1147 if (hasColor) {
1148 // In HWC1, color modes are referred to as color transforms. To avoid confusion with
1149 // the HWC2 concept of color transforms, we internally refer to them as color modes for
1150 // both HWC1 and 2.
1151 newConfig->setAttribute(ColorMode,
1152 values[attributeMap[HWC_DISPLAY_COLOR_TRANSFORM]]);
1153 }
1154
1155 // We can only do this after attempting to read the color mode
1156 newConfig->setHwc1Id(hwc1ConfigId);
1157
1158 for (auto& existingConfig : mConfigs) {
1159 if (existingConfig->merge(*newConfig)) {
1160 ALOGV("Merged config %d with existing config %u: %s",
1161 hwc1ConfigId, existingConfig->getId(),
1162 existingConfig->toString().c_str());
1163 newConfig.reset();
1164 break;
1165 }
1166 }
1167
1168 // If it wasn't merged with any existing config, add it to the end
1169 if (newConfig) {
1170 newConfig->setId(static_cast<hwc2_config_t>(mConfigs.size()));
1171 ALOGV("Found new config %u: %s", newConfig->getId(),
1172 newConfig->toString().c_str());
1173 mConfigs.emplace_back(std::move(newConfig));
1174 }
1175 }
1176
1177 initializeActiveConfig();
1178 populateColorModes();
1179 }
1180
populateConfigs(uint32_t width,uint32_t height)1181 void HWC2On1Adapter::Display::populateConfigs(uint32_t width, uint32_t height) {
1182 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1183
1184 mConfigs.emplace_back(std::make_shared<Config>(*this));
1185 auto& config = mConfigs[0];
1186
1187 config->setAttribute(Attribute::Width, static_cast<int32_t>(width));
1188 config->setAttribute(Attribute::Height, static_cast<int32_t>(height));
1189 config->setHwc1Id(0);
1190 config->setId(0);
1191 mActiveConfig = config;
1192 }
1193
prepare()1194 bool HWC2On1Adapter::Display::prepare() {
1195 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1196
1197 // Only prepare display contents for displays HWC1 knows about
1198 if (mHwc1Id == -1) {
1199 return true;
1200 }
1201
1202 // It doesn't make sense to prepare a display for which there is no active
1203 // config, so return early
1204 if (!mActiveConfig) {
1205 ALOGE("[%" PRIu64 "] Attempted to prepare, but no config active", mId);
1206 return false;
1207 }
1208
1209 allocateRequestedContents();
1210 assignHwc1LayerIds();
1211
1212 mHwc1RequestedContents->retireFenceFd = -1;
1213 mHwc1RequestedContents->flags = 0;
1214 if (mGeometryChanged) {
1215 mHwc1RequestedContents->flags |= HWC_GEOMETRY_CHANGED;
1216 }
1217 mHwc1RequestedContents->outbuf = mOutputBuffer.getBuffer();
1218 mHwc1RequestedContents->outbufAcquireFenceFd = mOutputBuffer.getFence();
1219
1220 // +1 is for framebuffer target layer.
1221 mHwc1RequestedContents->numHwLayers = mLayers.size() + 1;
1222 for (auto& layer : mLayers) {
1223 auto& hwc1Layer = mHwc1RequestedContents->hwLayers[layer->getHwc1Id()];
1224 hwc1Layer.releaseFenceFd = -1;
1225 hwc1Layer.acquireFenceFd = -1;
1226 ALOGV("Applying states for layer %" PRIu64 " ", layer->getId());
1227 layer->applyState(hwc1Layer);
1228 }
1229
1230 prepareFramebufferTarget();
1231
1232 resetGeometryMarker();
1233
1234 return true;
1235 }
1236
generateChanges()1237 void HWC2On1Adapter::Display::generateChanges() {
1238 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1239
1240 mChanges.reset(new Changes);
1241
1242 size_t numLayers = mHwc1RequestedContents->numHwLayers;
1243 for (size_t hwc1Id = 0; hwc1Id < numLayers; ++hwc1Id) {
1244 const auto& receivedLayer = mHwc1RequestedContents->hwLayers[hwc1Id];
1245 if (mHwc1LayerMap.count(hwc1Id) == 0) {
1246 ALOGE_IF(receivedLayer.compositionType != HWC_FRAMEBUFFER_TARGET,
1247 "generateChanges: HWC1 layer %zd doesn't have a"
1248 " matching HWC2 layer, and isn't the framebuffer target",
1249 hwc1Id);
1250 continue;
1251 }
1252
1253 Layer& layer = *mHwc1LayerMap[hwc1Id];
1254 updateTypeChanges(receivedLayer, layer);
1255 updateLayerRequests(receivedLayer, layer);
1256 }
1257 }
1258
hasChanges() const1259 bool HWC2On1Adapter::Display::hasChanges() const {
1260 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1261 return mChanges != nullptr;
1262 }
1263
set(hwc_display_contents_1 & hwcContents)1264 Error HWC2On1Adapter::Display::set(hwc_display_contents_1& hwcContents) {
1265 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1266
1267 if (!mChanges || (mChanges->getNumTypes() > 0)) {
1268 ALOGE("[%" PRIu64 "] set failed: not validated", mId);
1269 return Error::NotValidated;
1270 }
1271
1272 // Set up the client/framebuffer target
1273 auto numLayers = hwcContents.numHwLayers;
1274
1275 // Close acquire fences on FRAMEBUFFER layers, since they will not be used
1276 // by HWC
1277 for (size_t l = 0; l < numLayers - 1; ++l) {
1278 auto& layer = hwcContents.hwLayers[l];
1279 if (layer.compositionType == HWC_FRAMEBUFFER) {
1280 ALOGV("Closing fence %d for layer %zd", layer.acquireFenceFd, l);
1281 close(layer.acquireFenceFd);
1282 layer.acquireFenceFd = -1;
1283 }
1284 }
1285
1286 auto& clientTargetLayer = hwcContents.hwLayers[numLayers - 1];
1287 if (clientTargetLayer.compositionType == HWC_FRAMEBUFFER_TARGET) {
1288 clientTargetLayer.handle = mClientTarget.getBuffer();
1289 clientTargetLayer.acquireFenceFd = mClientTarget.getFence();
1290 } else {
1291 ALOGE("[%" PRIu64 "] set: last HWC layer wasn't FRAMEBUFFER_TARGET",
1292 mId);
1293 }
1294
1295 mChanges.reset();
1296
1297 return Error::None;
1298 }
1299
addRetireFence(int fenceFd)1300 void HWC2On1Adapter::Display::addRetireFence(int fenceFd) {
1301 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1302 mRetireFence.add(fenceFd);
1303 }
1304
addReleaseFences(const hwc_display_contents_1_t & hwcContents)1305 void HWC2On1Adapter::Display::addReleaseFences(
1306 const hwc_display_contents_1_t& hwcContents) {
1307 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1308
1309 size_t numLayers = hwcContents.numHwLayers;
1310 for (size_t hwc1Id = 0; hwc1Id < numLayers; ++hwc1Id) {
1311 const auto& receivedLayer = hwcContents.hwLayers[hwc1Id];
1312 if (mHwc1LayerMap.count(hwc1Id) == 0) {
1313 if (receivedLayer.compositionType != HWC_FRAMEBUFFER_TARGET) {
1314 ALOGE("addReleaseFences: HWC1 layer %zd doesn't have a"
1315 " matching HWC2 layer, and isn't the framebuffer"
1316 " target", hwc1Id);
1317 }
1318 // Close the framebuffer target release fence since we will use the
1319 // display retire fence instead
1320 if (receivedLayer.releaseFenceFd != -1) {
1321 close(receivedLayer.releaseFenceFd);
1322 }
1323 continue;
1324 }
1325
1326 Layer& layer = *mHwc1LayerMap[hwc1Id];
1327 ALOGV("Adding release fence %d to layer %" PRIu64,
1328 receivedLayer.releaseFenceFd, layer.getId());
1329 layer.addReleaseFence(receivedLayer.releaseFenceFd);
1330 }
1331 }
1332
hasColorTransform() const1333 bool HWC2On1Adapter::Display::hasColorTransform() const {
1334 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1335 return mHasColorTransform;
1336 }
1337
hwc1CompositionString(int32_t type)1338 static std::string hwc1CompositionString(int32_t type) {
1339 switch (type) {
1340 case HWC_FRAMEBUFFER: return "Framebuffer";
1341 case HWC_OVERLAY: return "Overlay";
1342 case HWC_BACKGROUND: return "Background";
1343 case HWC_FRAMEBUFFER_TARGET: return "FramebufferTarget";
1344 case HWC_SIDEBAND: return "Sideband";
1345 case HWC_CURSOR_OVERLAY: return "CursorOverlay";
1346 default:
1347 return std::string("Unknown (") + std::to_string(type) + ")";
1348 }
1349 }
1350
hwc1TransformString(int32_t transform)1351 static std::string hwc1TransformString(int32_t transform) {
1352 switch (transform) {
1353 case 0: return "None";
1354 case HWC_TRANSFORM_FLIP_H: return "FlipH";
1355 case HWC_TRANSFORM_FLIP_V: return "FlipV";
1356 case HWC_TRANSFORM_ROT_90: return "Rotate90";
1357 case HWC_TRANSFORM_ROT_180: return "Rotate180";
1358 case HWC_TRANSFORM_ROT_270: return "Rotate270";
1359 case HWC_TRANSFORM_FLIP_H_ROT_90: return "FlipHRotate90";
1360 case HWC_TRANSFORM_FLIP_V_ROT_90: return "FlipVRotate90";
1361 default:
1362 return std::string("Unknown (") + std::to_string(transform) + ")";
1363 }
1364 }
1365
hwc1BlendModeString(int32_t mode)1366 static std::string hwc1BlendModeString(int32_t mode) {
1367 switch (mode) {
1368 case HWC_BLENDING_NONE: return "None";
1369 case HWC_BLENDING_PREMULT: return "Premultiplied";
1370 case HWC_BLENDING_COVERAGE: return "Coverage";
1371 default:
1372 return std::string("Unknown (") + std::to_string(mode) + ")";
1373 }
1374 }
1375
rectString(hwc_rect_t rect)1376 static std::string rectString(hwc_rect_t rect) {
1377 std::stringstream output;
1378 output << "[" << rect.left << ", " << rect.top << ", ";
1379 output << rect.right << ", " << rect.bottom << "]";
1380 return output.str();
1381 }
1382
approximateFloatString(float f)1383 static std::string approximateFloatString(float f) {
1384 if (static_cast<int32_t>(f) == f) {
1385 return std::to_string(static_cast<int32_t>(f));
1386 }
1387 int32_t truncated = static_cast<int32_t>(f * 10);
1388 bool approximate = (static_cast<float>(truncated) != f * 10);
1389 const size_t BUFFER_SIZE = 32;
1390 char buffer[BUFFER_SIZE] = {};
1391 auto bytesWritten = snprintf(buffer, BUFFER_SIZE,
1392 "%s%.1f", approximate ? "~" : "", f);
1393 return std::string(buffer, bytesWritten);
1394 }
1395
frectString(hwc_frect_t frect)1396 static std::string frectString(hwc_frect_t frect) {
1397 std::stringstream output;
1398 output << "[" << approximateFloatString(frect.left) << ", ";
1399 output << approximateFloatString(frect.top) << ", ";
1400 output << approximateFloatString(frect.right) << ", ";
1401 output << approximateFloatString(frect.bottom) << "]";
1402 return output.str();
1403 }
1404
colorString(hwc_color_t color)1405 static std::string colorString(hwc_color_t color) {
1406 std::stringstream output;
1407 output << "RGBA [";
1408 output << static_cast<int32_t>(color.r) << ", ";
1409 output << static_cast<int32_t>(color.g) << ", ";
1410 output << static_cast<int32_t>(color.b) << ", ";
1411 output << static_cast<int32_t>(color.a) << "]";
1412 return output.str();
1413 }
1414
alphaString(float f)1415 static std::string alphaString(float f) {
1416 const size_t BUFFER_SIZE = 8;
1417 char buffer[BUFFER_SIZE] = {};
1418 auto bytesWritten = snprintf(buffer, BUFFER_SIZE, "%.3f", f);
1419 return std::string(buffer, bytesWritten);
1420 }
1421
to_string(const hwc_layer_1_t & hwcLayer,int32_t hwc1MinorVersion)1422 static std::string to_string(const hwc_layer_1_t& hwcLayer,
1423 int32_t hwc1MinorVersion) {
1424 const char* fill = " ";
1425
1426 std::stringstream output;
1427
1428 output << " Composition: " <<
1429 hwc1CompositionString(hwcLayer.compositionType);
1430
1431 if (hwcLayer.compositionType == HWC_BACKGROUND) {
1432 output << " Color: " << colorString(hwcLayer.backgroundColor) << '\n';
1433 } else if (hwcLayer.compositionType == HWC_SIDEBAND) {
1434 output << " Stream: " << hwcLayer.sidebandStream << '\n';
1435 } else {
1436 output << " Buffer: " << hwcLayer.handle << "/" <<
1437 hwcLayer.acquireFenceFd << '\n';
1438 }
1439
1440 output << fill << "Display frame: " << rectString(hwcLayer.displayFrame) <<
1441 '\n';
1442
1443 output << fill << "Source crop: ";
1444 if (hwc1MinorVersion >= 3) {
1445 output << frectString(hwcLayer.sourceCropf) << '\n';
1446 } else {
1447 output << rectString(hwcLayer.sourceCropi) << '\n';
1448 }
1449
1450 output << fill << "Transform: " << hwc1TransformString(hwcLayer.transform);
1451 output << " Blend mode: " << hwc1BlendModeString(hwcLayer.blending);
1452 if (hwcLayer.planeAlpha != 0xFF) {
1453 output << " Alpha: " << alphaString(hwcLayer.planeAlpha / 255.0f);
1454 }
1455 output << '\n';
1456
1457 if (hwcLayer.hints != 0) {
1458 output << fill << "Hints:";
1459 if ((hwcLayer.hints & HWC_HINT_TRIPLE_BUFFER) != 0) {
1460 output << " TripleBuffer";
1461 }
1462 if ((hwcLayer.hints & HWC_HINT_CLEAR_FB) != 0) {
1463 output << " ClearFB";
1464 }
1465 output << '\n';
1466 }
1467
1468 if (hwcLayer.flags != 0) {
1469 output << fill << "Flags:";
1470 if ((hwcLayer.flags & HWC_SKIP_LAYER) != 0) {
1471 output << " SkipLayer";
1472 }
1473 if ((hwcLayer.flags & HWC_IS_CURSOR_LAYER) != 0) {
1474 output << " IsCursorLayer";
1475 }
1476 output << '\n';
1477 }
1478
1479 return output.str();
1480 }
1481
to_string(const hwc_display_contents_1_t & hwcContents,int32_t hwc1MinorVersion)1482 static std::string to_string(const hwc_display_contents_1_t& hwcContents,
1483 int32_t hwc1MinorVersion) {
1484 const char* fill = " ";
1485
1486 std::stringstream output;
1487 output << fill << "Geometry changed: " <<
1488 ((hwcContents.flags & HWC_GEOMETRY_CHANGED) != 0 ? "Y\n" : "N\n");
1489
1490 output << fill << hwcContents.numHwLayers << " Layer" <<
1491 ((hwcContents.numHwLayers == 1) ? "\n" : "s\n");
1492 for (size_t layer = 0; layer < hwcContents.numHwLayers; ++layer) {
1493 output << fill << " Layer " << layer;
1494 output << to_string(hwcContents.hwLayers[layer], hwc1MinorVersion);
1495 }
1496
1497 if (hwcContents.outbuf != nullptr) {
1498 output << fill << "Output buffer: " << hwcContents.outbuf << "/" <<
1499 hwcContents.outbufAcquireFenceFd << '\n';
1500 }
1501
1502 return output.str();
1503 }
1504
dump() const1505 std::string HWC2On1Adapter::Display::dump() const {
1506 std::unique_lock<std::recursive_mutex> lock(mStateMutex);
1507
1508 std::stringstream output;
1509
1510 output << " Display " << mId << ": ";
1511 output << to_string(mType) << " ";
1512 output << "HWC1 ID: " << mHwc1Id << " ";
1513 output << "Power mode: " << to_string(mPowerMode) << " ";
1514 output << "Vsync: " << to_string(mVsyncEnabled) << '\n';
1515
1516 output << " Color modes [active]:";
1517 for (const auto& mode : mColorModes) {
1518 if (mode == mActiveColorMode) {
1519 output << " [" << mode << ']';
1520 } else {
1521 output << " " << mode;
1522 }
1523 }
1524 output << '\n';
1525
1526 output << " " << mConfigs.size() << " Config" <<
1527 (mConfigs.size() == 1 ? "" : "s") << " (* active)\n";
1528 for (const auto& config : mConfigs) {
1529 output << (config == mActiveConfig ? " * " : " ");
1530 output << config->toString(true) << '\n';
1531 }
1532
1533 output << " " << mLayers.size() << " Layer" <<
1534 (mLayers.size() == 1 ? "" : "s") << '\n';
1535 for (const auto& layer : mLayers) {
1536 output << layer->dump();
1537 }
1538
1539 output << " Client target: " << mClientTarget.getBuffer() << '\n';
1540
1541 if (mOutputBuffer.getBuffer() != nullptr) {
1542 output << " Output buffer: " << mOutputBuffer.getBuffer() << '\n';
1543 }
1544
1545 if (mHwc1RequestedContents) {
1546 output << " Last requested HWC1 state\n";
1547 output << to_string(*mHwc1RequestedContents, mDevice.mHwc1MinorVersion);
1548 }
1549
1550 return output.str();
1551 }
1552
GetRects(size_t numRects)1553 hwc_rect_t* HWC2On1Adapter::Display::GetRects(size_t numRects) {
1554 if (numRects == 0) {
1555 return nullptr;
1556 }
1557
1558 if (numRects > mNumAvailableRects) {
1559 // This should NEVER happen since we calculated how many rects the
1560 // display would need.
1561 ALOGE("Rect allocation failure! SF is likely to crash soon!");
1562 return nullptr;
1563
1564 }
1565 hwc_rect_t* rects = mNextAvailableRect;
1566 mNextAvailableRect += numRects;
1567 mNumAvailableRects -= numRects;
1568 return rects;
1569 }
1570
getDisplayContents()1571 hwc_display_contents_1* HWC2On1Adapter::Display::getDisplayContents() {
1572 return mHwc1RequestedContents.get();
1573 }
1574
setAttribute(HWC2::Attribute attribute,int32_t value)1575 void HWC2On1Adapter::Display::Config::setAttribute(HWC2::Attribute attribute,
1576 int32_t value) {
1577 mAttributes[attribute] = value;
1578 }
1579
getAttribute(Attribute attribute) const1580 int32_t HWC2On1Adapter::Display::Config::getAttribute(Attribute attribute) const {
1581 if (mAttributes.count(attribute) == 0) {
1582 return -1;
1583 }
1584 return mAttributes.at(attribute);
1585 }
1586
setHwc1Id(uint32_t id)1587 void HWC2On1Adapter::Display::Config::setHwc1Id(uint32_t id) {
1588 android_color_mode_t colorMode = static_cast<android_color_mode_t>(getAttribute(ColorMode));
1589 mHwc1Ids.emplace(colorMode, id);
1590 }
1591
hasHwc1Id(uint32_t id) const1592 bool HWC2On1Adapter::Display::Config::hasHwc1Id(uint32_t id) const {
1593 for (const auto& idPair : mHwc1Ids) {
1594 if (id == idPair.second) {
1595 return true;
1596 }
1597 }
1598 return false;
1599 }
1600
getColorModeForHwc1Id(uint32_t id,android_color_mode_t * outMode) const1601 Error HWC2On1Adapter::Display::Config::getColorModeForHwc1Id(
1602 uint32_t id, android_color_mode_t* outMode) const {
1603 for (const auto& idPair : mHwc1Ids) {
1604 if (id == idPair.second) {
1605 *outMode = idPair.first;
1606 return Error::None;
1607 }
1608 }
1609 ALOGE("Unable to find color mode for HWC ID %" PRIu32 " on config %u", id, mId);
1610 return Error::BadParameter;
1611 }
1612
getHwc1IdForColorMode(android_color_mode_t mode,uint32_t * outId) const1613 Error HWC2On1Adapter::Display::Config::getHwc1IdForColorMode(android_color_mode_t mode,
1614 uint32_t* outId) const {
1615 for (const auto& idPair : mHwc1Ids) {
1616 if (mode == idPair.first) {
1617 *outId = idPair.second;
1618 return Error::None;
1619 }
1620 }
1621 ALOGE("Unable to find HWC1 ID for color mode %d on config %u", mode, mId);
1622 return Error::BadParameter;
1623 }
1624
merge(const Config & other)1625 bool HWC2On1Adapter::Display::Config::merge(const Config& other) {
1626 auto attributes = {HWC2::Attribute::Width, HWC2::Attribute::Height,
1627 HWC2::Attribute::VsyncPeriod, HWC2::Attribute::DpiX,
1628 HWC2::Attribute::DpiY};
1629 for (auto attribute : attributes) {
1630 if (getAttribute(attribute) != other.getAttribute(attribute)) {
1631 return false;
1632 }
1633 }
1634 android_color_mode_t otherColorMode =
1635 static_cast<android_color_mode_t>(other.getAttribute(ColorMode));
1636 if (mHwc1Ids.count(otherColorMode) != 0) {
1637 ALOGE("Attempted to merge two configs (%u and %u) which appear to be "
1638 "identical", mHwc1Ids.at(otherColorMode),
1639 other.mHwc1Ids.at(otherColorMode));
1640 return false;
1641 }
1642 mHwc1Ids.emplace(otherColorMode,
1643 other.mHwc1Ids.at(otherColorMode));
1644 return true;
1645 }
1646
getColorModes() const1647 std::set<android_color_mode_t> HWC2On1Adapter::Display::Config::getColorModes() const {
1648 std::set<android_color_mode_t> colorModes;
1649 for (const auto& idPair : mHwc1Ids) {
1650 colorModes.emplace(idPair.first);
1651 }
1652 return colorModes;
1653 }
1654
toString(bool splitLine) const1655 std::string HWC2On1Adapter::Display::Config::toString(bool splitLine) const {
1656 std::string output;
1657
1658 const size_t BUFFER_SIZE = 100;
1659 char buffer[BUFFER_SIZE] = {};
1660 auto writtenBytes = snprintf(buffer, BUFFER_SIZE,
1661 "%u x %u", mAttributes.at(HWC2::Attribute::Width),
1662 mAttributes.at(HWC2::Attribute::Height));
1663 output.append(buffer, writtenBytes);
1664
1665 if (mAttributes.count(HWC2::Attribute::VsyncPeriod) != 0) {
1666 std::memset(buffer, 0, BUFFER_SIZE);
1667 writtenBytes = snprintf(buffer, BUFFER_SIZE, " @ %.1f Hz",
1668 1e9 / mAttributes.at(HWC2::Attribute::VsyncPeriod));
1669 output.append(buffer, writtenBytes);
1670 }
1671
1672 if (mAttributes.count(HWC2::Attribute::DpiX) != 0 &&
1673 mAttributes.at(HWC2::Attribute::DpiX) != -1) {
1674 std::memset(buffer, 0, BUFFER_SIZE);
1675 writtenBytes = snprintf(buffer, BUFFER_SIZE,
1676 ", DPI: %.1f x %.1f",
1677 mAttributes.at(HWC2::Attribute::DpiX) / 1000.0f,
1678 mAttributes.at(HWC2::Attribute::DpiY) / 1000.0f);
1679 output.append(buffer, writtenBytes);
1680 }
1681
1682 std::memset(buffer, 0, BUFFER_SIZE);
1683 if (splitLine) {
1684 writtenBytes = snprintf(buffer, BUFFER_SIZE,
1685 "\n HWC1 ID/Color transform:");
1686 } else {
1687 writtenBytes = snprintf(buffer, BUFFER_SIZE,
1688 ", HWC1 ID/Color transform:");
1689 }
1690 output.append(buffer, writtenBytes);
1691
1692
1693 for (const auto& id : mHwc1Ids) {
1694 android_color_mode_t colorMode = id.first;
1695 uint32_t hwc1Id = id.second;
1696 std::memset(buffer, 0, BUFFER_SIZE);
1697 if (colorMode == mDisplay.mActiveColorMode) {
1698 writtenBytes = snprintf(buffer, BUFFER_SIZE, " [%u/%d]", hwc1Id,
1699 colorMode);
1700 } else {
1701 writtenBytes = snprintf(buffer, BUFFER_SIZE, " %u/%d", hwc1Id,
1702 colorMode);
1703 }
1704 output.append(buffer, writtenBytes);
1705 }
1706
1707 return output;
1708 }
1709
1710 std::shared_ptr<const HWC2On1Adapter::Display::Config>
getConfig(hwc2_config_t configId) const1711 HWC2On1Adapter::Display::getConfig(hwc2_config_t configId) const {
1712 if (configId > mConfigs.size() || !mConfigs[configId]->isOnDisplay(*this)) {
1713 return nullptr;
1714 }
1715 return mConfigs[configId];
1716 }
1717
populateColorModes()1718 void HWC2On1Adapter::Display::populateColorModes() {
1719 mColorModes = mConfigs[0]->getColorModes();
1720 for (const auto& config : mConfigs) {
1721 std::set<android_color_mode_t> intersection;
1722 auto configModes = config->getColorModes();
1723 std::set_intersection(mColorModes.cbegin(), mColorModes.cend(),
1724 configModes.cbegin(), configModes.cend(),
1725 std::inserter(intersection, intersection.begin()));
1726 std::swap(intersection, mColorModes);
1727 }
1728 }
1729
initializeActiveConfig()1730 void HWC2On1Adapter::Display::initializeActiveConfig() {
1731 if (mDevice.mHwc1Device->getActiveConfig == nullptr) {
1732 ALOGV("getActiveConfig is null, choosing config 0");
1733 mActiveConfig = mConfigs[0];
1734 mActiveColorMode = HAL_COLOR_MODE_NATIVE;
1735 return;
1736 }
1737
1738 auto activeConfig = mDevice.mHwc1Device->getActiveConfig(
1739 mDevice.mHwc1Device, mHwc1Id);
1740
1741 // Some devices startup without an activeConfig:
1742 // We need to set one ourselves.
1743 if (activeConfig == HWC_ERROR) {
1744 ALOGV("There is no active configuration: Picking the first one: 0.");
1745 const int defaultIndex = 0;
1746 mDevice.mHwc1Device->setActiveConfig(mDevice.mHwc1Device, mHwc1Id, defaultIndex);
1747 activeConfig = defaultIndex;
1748 }
1749
1750 for (const auto& config : mConfigs) {
1751 if (config->hasHwc1Id(activeConfig)) {
1752 ALOGE("Setting active config to %d for HWC1 config %u", config->getId(), activeConfig);
1753 mActiveConfig = config;
1754 if (config->getColorModeForHwc1Id(activeConfig, &mActiveColorMode) != Error::None) {
1755 // This should never happen since we checked for the config's presence before
1756 // setting it as active.
1757 ALOGE("Unable to find color mode for active HWC1 config %d", config->getId());
1758 mActiveColorMode = HAL_COLOR_MODE_NATIVE;
1759 }
1760 break;
1761 }
1762 }
1763 if (!mActiveConfig) {
1764 ALOGV("Unable to find active HWC1 config %u, defaulting to "
1765 "config 0", activeConfig);
1766 mActiveConfig = mConfigs[0];
1767 mActiveColorMode = HAL_COLOR_MODE_NATIVE;
1768 }
1769
1770
1771
1772
1773 }
1774
allocateRequestedContents()1775 void HWC2On1Adapter::Display::allocateRequestedContents() {
1776 // What needs to be allocated:
1777 // 1 hwc_display_contents_1_t
1778 // 1 hwc_layer_1_t for each layer
1779 // 1 hwc_rect_t for each layer's surfaceDamage
1780 // 1 hwc_rect_t for each layer's visibleRegion
1781 // 1 hwc_layer_1_t for the framebuffer
1782 // 1 hwc_rect_t for the framebuffer's visibleRegion
1783
1784 // Count # of surfaceDamage
1785 size_t numSurfaceDamages = 0;
1786 for (const auto& layer : mLayers) {
1787 numSurfaceDamages += layer->getNumSurfaceDamages();
1788 }
1789
1790 // Count # of visibleRegions (start at 1 for mandatory framebuffer target
1791 // region)
1792 size_t numVisibleRegion = 1;
1793 for (const auto& layer : mLayers) {
1794 numVisibleRegion += layer->getNumVisibleRegions();
1795 }
1796
1797 size_t numRects = numVisibleRegion + numSurfaceDamages;
1798 auto numLayers = mLayers.size() + 1;
1799 size_t size = sizeof(hwc_display_contents_1_t) +
1800 sizeof(hwc_layer_1_t) * numLayers +
1801 sizeof(hwc_rect_t) * numRects;
1802 auto contents = static_cast<hwc_display_contents_1_t*>(std::calloc(size, 1));
1803 mHwc1RequestedContents.reset(contents);
1804 mNextAvailableRect = reinterpret_cast<hwc_rect_t*>(&contents->hwLayers[numLayers]);
1805 mNumAvailableRects = numRects;
1806 }
1807
assignHwc1LayerIds()1808 void HWC2On1Adapter::Display::assignHwc1LayerIds() {
1809 mHwc1LayerMap.clear();
1810 size_t nextHwc1Id = 0;
1811 for (auto& layer : mLayers) {
1812 mHwc1LayerMap[nextHwc1Id] = layer;
1813 layer->setHwc1Id(nextHwc1Id++);
1814 }
1815 }
1816
updateTypeChanges(const hwc_layer_1_t & hwc1Layer,const Layer & layer)1817 void HWC2On1Adapter::Display::updateTypeChanges(const hwc_layer_1_t& hwc1Layer,
1818 const Layer& layer) {
1819 auto layerId = layer.getId();
1820 switch (hwc1Layer.compositionType) {
1821 case HWC_FRAMEBUFFER:
1822 if (layer.getCompositionType() != Composition::Client) {
1823 mChanges->addTypeChange(layerId, Composition::Client);
1824 }
1825 break;
1826 case HWC_OVERLAY:
1827 if (layer.getCompositionType() != Composition::Device) {
1828 mChanges->addTypeChange(layerId, Composition::Device);
1829 }
1830 break;
1831 case HWC_BACKGROUND:
1832 ALOGE_IF(layer.getCompositionType() != Composition::SolidColor,
1833 "updateTypeChanges: HWC1 requested BACKGROUND, but HWC2"
1834 " wasn't expecting SolidColor");
1835 break;
1836 case HWC_FRAMEBUFFER_TARGET:
1837 // Do nothing, since it shouldn't be modified by HWC1
1838 break;
1839 case HWC_SIDEBAND:
1840 ALOGE_IF(layer.getCompositionType() != Composition::Sideband,
1841 "updateTypeChanges: HWC1 requested SIDEBAND, but HWC2"
1842 " wasn't expecting Sideband");
1843 break;
1844 case HWC_CURSOR_OVERLAY:
1845 ALOGE_IF(layer.getCompositionType() != Composition::Cursor,
1846 "updateTypeChanges: HWC1 requested CURSOR_OVERLAY, but"
1847 " HWC2 wasn't expecting Cursor");
1848 break;
1849 }
1850 }
1851
updateLayerRequests(const hwc_layer_1_t & hwc1Layer,const Layer & layer)1852 void HWC2On1Adapter::Display::updateLayerRequests(
1853 const hwc_layer_1_t& hwc1Layer, const Layer& layer) {
1854 if ((hwc1Layer.hints & HWC_HINT_CLEAR_FB) != 0) {
1855 mChanges->addLayerRequest(layer.getId(),
1856 LayerRequest::ClearClientTarget);
1857 }
1858 }
1859
prepareFramebufferTarget()1860 void HWC2On1Adapter::Display::prepareFramebufferTarget() {
1861 // We check that mActiveConfig is valid in Display::prepare
1862 int32_t width = mActiveConfig->getAttribute(Attribute::Width);
1863 int32_t height = mActiveConfig->getAttribute(Attribute::Height);
1864
1865 auto& hwc1Target = mHwc1RequestedContents->hwLayers[mLayers.size()];
1866 hwc1Target.compositionType = HWC_FRAMEBUFFER_TARGET;
1867 hwc1Target.releaseFenceFd = -1;
1868 hwc1Target.hints = 0;
1869 hwc1Target.flags = 0;
1870 hwc1Target.transform = 0;
1871 hwc1Target.blending = HWC_BLENDING_PREMULT;
1872 if (mDevice.getHwc1MinorVersion() < 3) {
1873 hwc1Target.sourceCropi = {0, 0, width, height};
1874 } else {
1875 hwc1Target.sourceCropf = {0.0f, 0.0f, static_cast<float>(width),
1876 static_cast<float>(height)};
1877 }
1878 hwc1Target.displayFrame = {0, 0, width, height};
1879 hwc1Target.planeAlpha = 255;
1880
1881 hwc1Target.visibleRegionScreen.numRects = 1;
1882 hwc_rect_t* rects = GetRects(1);
1883 rects[0].left = 0;
1884 rects[0].top = 0;
1885 rects[0].right = width;
1886 rects[0].bottom = height;
1887 hwc1Target.visibleRegionScreen.rects = rects;
1888
1889 // We will set this to the correct value in set
1890 hwc1Target.acquireFenceFd = -1;
1891 }
1892
1893 // Layer functions
1894
1895 std::atomic<hwc2_layer_t> HWC2On1Adapter::Layer::sNextId(1);
1896
Layer(Display & display)1897 HWC2On1Adapter::Layer::Layer(Display& display)
1898 : mId(sNextId++),
1899 mDisplay(display),
1900 mBuffer(),
1901 mSurfaceDamage(),
1902 mBlendMode(BlendMode::None),
1903 mColor({0, 0, 0, 0}),
1904 mCompositionType(Composition::Invalid),
1905 mDisplayFrame({0, 0, -1, -1}),
1906 mPlaneAlpha(0.0f),
1907 mSidebandStream(nullptr),
1908 mSourceCrop({0.0f, 0.0f, -1.0f, -1.0f}),
1909 mTransform(Transform::None),
1910 mVisibleRegion(),
1911 mZ(0),
1912 mReleaseFence(),
1913 mHwc1Id(0),
1914 mHasUnsupportedPlaneAlpha(false) {}
1915
operator ()(const std::shared_ptr<Layer> & lhs,const std::shared_ptr<Layer> & rhs)1916 bool HWC2On1Adapter::SortLayersByZ::operator()(
1917 const std::shared_ptr<Layer>& lhs, const std::shared_ptr<Layer>& rhs) {
1918 return lhs->getZ() < rhs->getZ();
1919 }
1920
setBuffer(buffer_handle_t buffer,int32_t acquireFence)1921 Error HWC2On1Adapter::Layer::setBuffer(buffer_handle_t buffer,
1922 int32_t acquireFence) {
1923 ALOGV("Setting acquireFence to %d for layer %" PRIu64, acquireFence, mId);
1924 mBuffer.setBuffer(buffer);
1925 mBuffer.setFence(acquireFence);
1926 return Error::None;
1927 }
1928
setCursorPosition(int32_t x,int32_t y)1929 Error HWC2On1Adapter::Layer::setCursorPosition(int32_t x, int32_t y) {
1930 if (mCompositionType != Composition::Cursor) {
1931 return Error::BadLayer;
1932 }
1933
1934 if (mDisplay.hasChanges()) {
1935 return Error::NotValidated;
1936 }
1937
1938 auto displayId = mDisplay.getHwc1Id();
1939 auto hwc1Device = mDisplay.getDevice().getHwc1Device();
1940 hwc1Device->setCursorPositionAsync(hwc1Device, displayId, x, y);
1941 return Error::None;
1942 }
1943
setSurfaceDamage(hwc_region_t damage)1944 Error HWC2On1Adapter::Layer::setSurfaceDamage(hwc_region_t damage) {
1945 // HWC1 supports surface damage starting only with version 1.5.
1946 if (mDisplay.getDevice().mHwc1MinorVersion < 5) {
1947 return Error::None;
1948 }
1949 mSurfaceDamage.resize(damage.numRects);
1950 std::copy_n(damage.rects, damage.numRects, mSurfaceDamage.begin());
1951 return Error::None;
1952 }
1953
1954 // Layer state functions
1955
setBlendMode(BlendMode mode)1956 Error HWC2On1Adapter::Layer::setBlendMode(BlendMode mode) {
1957 mBlendMode = mode;
1958 mDisplay.markGeometryChanged();
1959 return Error::None;
1960 }
1961
setColor(hwc_color_t color)1962 Error HWC2On1Adapter::Layer::setColor(hwc_color_t color) {
1963 mColor = color;
1964 mDisplay.markGeometryChanged();
1965 return Error::None;
1966 }
1967
setCompositionType(Composition type)1968 Error HWC2On1Adapter::Layer::setCompositionType(Composition type) {
1969 mCompositionType = type;
1970 mDisplay.markGeometryChanged();
1971 return Error::None;
1972 }
1973
setDataspace(android_dataspace_t)1974 Error HWC2On1Adapter::Layer::setDataspace(android_dataspace_t) {
1975 return Error::None;
1976 }
1977
setDisplayFrame(hwc_rect_t frame)1978 Error HWC2On1Adapter::Layer::setDisplayFrame(hwc_rect_t frame) {
1979 mDisplayFrame = frame;
1980 mDisplay.markGeometryChanged();
1981 return Error::None;
1982 }
1983
setPlaneAlpha(float alpha)1984 Error HWC2On1Adapter::Layer::setPlaneAlpha(float alpha) {
1985 mPlaneAlpha = alpha;
1986 mDisplay.markGeometryChanged();
1987 return Error::None;
1988 }
1989
setSidebandStream(const native_handle_t * stream)1990 Error HWC2On1Adapter::Layer::setSidebandStream(const native_handle_t* stream) {
1991 mSidebandStream = stream;
1992 mDisplay.markGeometryChanged();
1993 return Error::None;
1994 }
1995
setSourceCrop(hwc_frect_t crop)1996 Error HWC2On1Adapter::Layer::setSourceCrop(hwc_frect_t crop) {
1997 mSourceCrop = crop;
1998 mDisplay.markGeometryChanged();
1999 return Error::None;
2000 }
2001
setTransform(Transform transform)2002 Error HWC2On1Adapter::Layer::setTransform(Transform transform) {
2003 mTransform = transform;
2004 mDisplay.markGeometryChanged();
2005 return Error::None;
2006 }
2007
setVisibleRegion(hwc_region_t visible)2008 Error HWC2On1Adapter::Layer::setVisibleRegion(hwc_region_t visible) {
2009 mVisibleRegion.resize(visible.numRects);
2010 std::copy_n(visible.rects, visible.numRects, mVisibleRegion.begin());
2011 mDisplay.markGeometryChanged();
2012 return Error::None;
2013 }
2014
setZ(uint32_t z)2015 Error HWC2On1Adapter::Layer::setZ(uint32_t z) {
2016 mZ = z;
2017 return Error::None;
2018 }
2019
addReleaseFence(int fenceFd)2020 void HWC2On1Adapter::Layer::addReleaseFence(int fenceFd) {
2021 ALOGV("addReleaseFence %d to layer %" PRIu64, fenceFd, mId);
2022 mReleaseFence.add(fenceFd);
2023 }
2024
getReleaseFence() const2025 const sp<MiniFence>& HWC2On1Adapter::Layer::getReleaseFence() const {
2026 return mReleaseFence.get();
2027 }
2028
applyState(hwc_layer_1_t & hwc1Layer)2029 void HWC2On1Adapter::Layer::applyState(hwc_layer_1_t& hwc1Layer) {
2030 applyCommonState(hwc1Layer);
2031 applyCompositionType(hwc1Layer);
2032 switch (mCompositionType) {
2033 case Composition::SolidColor : applySolidColorState(hwc1Layer); break;
2034 case Composition::Sideband : applySidebandState(hwc1Layer); break;
2035 default: applyBufferState(hwc1Layer); break;
2036 }
2037 }
2038
regionStrings(const std::vector<hwc_rect_t> & visibleRegion,const std::vector<hwc_rect_t> & surfaceDamage)2039 static std::string regionStrings(const std::vector<hwc_rect_t>& visibleRegion,
2040 const std::vector<hwc_rect_t>& surfaceDamage) {
2041 std::string regions;
2042 regions += " Visible Region";
2043 regions.resize(40, ' ');
2044 regions += "Surface Damage\n";
2045
2046 size_t numPrinted = 0;
2047 size_t maxSize = std::max(visibleRegion.size(), surfaceDamage.size());
2048 while (numPrinted < maxSize) {
2049 std::string line(" ");
2050 if (visibleRegion.empty() && numPrinted == 0) {
2051 line += "None";
2052 } else if (numPrinted < visibleRegion.size()) {
2053 line += rectString(visibleRegion[numPrinted]);
2054 }
2055 line.resize(40, ' ');
2056 if (surfaceDamage.empty() && numPrinted == 0) {
2057 line += "None";
2058 } else if (numPrinted < surfaceDamage.size()) {
2059 line += rectString(surfaceDamage[numPrinted]);
2060 }
2061 line += '\n';
2062 regions += line;
2063 ++numPrinted;
2064 }
2065 return regions;
2066 }
2067
dump() const2068 std::string HWC2On1Adapter::Layer::dump() const {
2069 std::stringstream output;
2070 const char* fill = " ";
2071
2072 output << fill << to_string(mCompositionType);
2073 output << " Layer HWC2/1: " << mId << "/" << mHwc1Id << " ";
2074 output << "Z: " << mZ;
2075 if (mCompositionType == HWC2::Composition::SolidColor) {
2076 output << " " << colorString(mColor);
2077 } else if (mCompositionType == HWC2::Composition::Sideband) {
2078 output << " Handle: " << mSidebandStream << '\n';
2079 } else {
2080 output << " Buffer: " << mBuffer.getBuffer() << "/" <<
2081 mBuffer.getFence() << '\n';
2082 output << fill << " Display frame [LTRB]: " <<
2083 rectString(mDisplayFrame) << '\n';
2084 output << fill << " Source crop: " <<
2085 frectString(mSourceCrop) << '\n';
2086 output << fill << " Transform: " << to_string(mTransform);
2087 output << " Blend mode: " << to_string(mBlendMode);
2088 if (mPlaneAlpha != 1.0f) {
2089 output << " Alpha: " <<
2090 alphaString(mPlaneAlpha) << '\n';
2091 } else {
2092 output << '\n';
2093 }
2094 output << regionStrings(mVisibleRegion, mSurfaceDamage);
2095 }
2096 return output.str();
2097 }
2098
getHwc1Blending(HWC2::BlendMode blendMode)2099 static int getHwc1Blending(HWC2::BlendMode blendMode) {
2100 switch (blendMode) {
2101 case BlendMode::Coverage: return HWC_BLENDING_COVERAGE;
2102 case BlendMode::Premultiplied: return HWC_BLENDING_PREMULT;
2103 default: return HWC_BLENDING_NONE;
2104 }
2105 }
2106
applyCommonState(hwc_layer_1_t & hwc1Layer)2107 void HWC2On1Adapter::Layer::applyCommonState(hwc_layer_1_t& hwc1Layer) {
2108 auto minorVersion = mDisplay.getDevice().getHwc1MinorVersion();
2109 hwc1Layer.blending = getHwc1Blending(mBlendMode);
2110 hwc1Layer.displayFrame = mDisplayFrame;
2111
2112 auto pendingAlpha = mPlaneAlpha;
2113 if (minorVersion < 2) {
2114 mHasUnsupportedPlaneAlpha = pendingAlpha < 1.0f;
2115 } else {
2116 hwc1Layer.planeAlpha =
2117 static_cast<uint8_t>(255.0f * pendingAlpha + 0.5f);
2118 }
2119
2120 if (minorVersion < 3) {
2121 auto pending = mSourceCrop;
2122 hwc1Layer.sourceCropi.left =
2123 static_cast<int32_t>(std::ceil(pending.left));
2124 hwc1Layer.sourceCropi.top =
2125 static_cast<int32_t>(std::ceil(pending.top));
2126 hwc1Layer.sourceCropi.right =
2127 static_cast<int32_t>(std::floor(pending.right));
2128 hwc1Layer.sourceCropi.bottom =
2129 static_cast<int32_t>(std::floor(pending.bottom));
2130 } else {
2131 hwc1Layer.sourceCropf = mSourceCrop;
2132 }
2133
2134 hwc1Layer.transform = static_cast<uint32_t>(mTransform);
2135
2136 auto& hwc1VisibleRegion = hwc1Layer.visibleRegionScreen;
2137 hwc1VisibleRegion.numRects = mVisibleRegion.size();
2138 hwc_rect_t* rects = mDisplay.GetRects(hwc1VisibleRegion.numRects);
2139 hwc1VisibleRegion.rects = rects;
2140 for (size_t i = 0; i < mVisibleRegion.size(); i++) {
2141 rects[i] = mVisibleRegion[i];
2142 }
2143 }
2144
applySolidColorState(hwc_layer_1_t & hwc1Layer)2145 void HWC2On1Adapter::Layer::applySolidColorState(hwc_layer_1_t& hwc1Layer) {
2146 // If the device does not support background color it is likely to make
2147 // assumption regarding backgroundColor and handle (both fields occupy
2148 // the same location in hwc_layer_1_t union).
2149 // To not confuse these devices we don't set background color and we
2150 // make sure handle is a null pointer.
2151 if (hasUnsupportedBackgroundColor()) {
2152 hwc1Layer.handle = nullptr;
2153 } else {
2154 hwc1Layer.backgroundColor = mColor;
2155 }
2156 }
2157
applySidebandState(hwc_layer_1_t & hwc1Layer)2158 void HWC2On1Adapter::Layer::applySidebandState(hwc_layer_1_t& hwc1Layer) {
2159 hwc1Layer.sidebandStream = mSidebandStream;
2160 }
2161
applyBufferState(hwc_layer_1_t & hwc1Layer)2162 void HWC2On1Adapter::Layer::applyBufferState(hwc_layer_1_t& hwc1Layer) {
2163 hwc1Layer.handle = mBuffer.getBuffer();
2164 hwc1Layer.acquireFenceFd = mBuffer.getFence();
2165 }
2166
applyCompositionType(hwc_layer_1_t & hwc1Layer)2167 void HWC2On1Adapter::Layer::applyCompositionType(hwc_layer_1_t& hwc1Layer) {
2168 // HWC1 never supports color transforms or dataspaces and only sometimes
2169 // supports plane alpha (depending on the version). These require us to drop
2170 // some or all layers to client composition.
2171 if (mHasUnsupportedPlaneAlpha || mDisplay.hasColorTransform() ||
2172 hasUnsupportedBackgroundColor()) {
2173 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2174 hwc1Layer.flags = HWC_SKIP_LAYER;
2175 return;
2176 }
2177
2178 hwc1Layer.flags = 0;
2179 switch (mCompositionType) {
2180 case Composition::Client:
2181 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2182 hwc1Layer.flags |= HWC_SKIP_LAYER;
2183 break;
2184 case Composition::Device:
2185 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2186 break;
2187 case Composition::SolidColor:
2188 // In theory the following line should work, but since the HWC1
2189 // version of SurfaceFlinger never used HWC_BACKGROUND, HWC1
2190 // devices may not work correctly. To be on the safe side, we
2191 // fall back to client composition.
2192 //
2193 // hwc1Layer.compositionType = HWC_BACKGROUND;
2194 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2195 hwc1Layer.flags |= HWC_SKIP_LAYER;
2196 break;
2197 case Composition::Cursor:
2198 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2199 if (mDisplay.getDevice().getHwc1MinorVersion() >= 4) {
2200 hwc1Layer.hints |= HWC_IS_CURSOR_LAYER;
2201 }
2202 break;
2203 case Composition::Sideband:
2204 if (mDisplay.getDevice().getHwc1MinorVersion() < 4) {
2205 hwc1Layer.compositionType = HWC_SIDEBAND;
2206 } else {
2207 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2208 hwc1Layer.flags |= HWC_SKIP_LAYER;
2209 }
2210 break;
2211 default:
2212 hwc1Layer.compositionType = HWC_FRAMEBUFFER;
2213 hwc1Layer.flags |= HWC_SKIP_LAYER;
2214 break;
2215 }
2216 ALOGV("Layer %" PRIu64 " %s set to %d", mId,
2217 to_string(mCompositionType).c_str(),
2218 hwc1Layer.compositionType);
2219 ALOGV_IF(hwc1Layer.flags & HWC_SKIP_LAYER, " and skipping");
2220 }
2221
2222 // Adapter helpers
2223
populateCapabilities()2224 void HWC2On1Adapter::populateCapabilities() {
2225 if (mHwc1MinorVersion >= 3U) {
2226 int supportedTypes = 0;
2227 auto result = mHwc1Device->query(mHwc1Device,
2228 HWC_DISPLAY_TYPES_SUPPORTED, &supportedTypes);
2229 if ((result == 0) && ((supportedTypes & HWC_DISPLAY_VIRTUAL_BIT) != 0)) {
2230 ALOGI("Found support for HWC virtual displays");
2231 mHwc1SupportsVirtualDisplays = true;
2232 }
2233 }
2234 if (mHwc1MinorVersion >= 4U) {
2235 mCapabilities.insert(Capability::SidebandStream);
2236 }
2237
2238 // Check for HWC background color layer support.
2239 if (mHwc1MinorVersion >= 1U) {
2240 int backgroundColorSupported = 0;
2241 auto result = mHwc1Device->query(mHwc1Device,
2242 HWC_BACKGROUND_LAYER_SUPPORTED,
2243 &backgroundColorSupported);
2244 if ((result == 0) && (backgroundColorSupported == 1)) {
2245 ALOGV("Found support for HWC background color");
2246 mHwc1SupportsBackgroundColor = true;
2247 }
2248 }
2249
2250 // Some devices might have HWC1 retire fences that accurately emulate
2251 // HWC2 present fences when they are deferred, but it's not very reliable.
2252 // To be safe, we indicate PresentFenceIsNotReliable for all HWC1 devices.
2253 mCapabilities.insert(Capability::PresentFenceIsNotReliable);
2254 }
2255
getDisplay(hwc2_display_t id)2256 HWC2On1Adapter::Display* HWC2On1Adapter::getDisplay(hwc2_display_t id) {
2257 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2258
2259 auto display = mDisplays.find(id);
2260 if (display == mDisplays.end()) {
2261 return nullptr;
2262 }
2263
2264 return display->second.get();
2265 }
2266
getLayer(hwc2_display_t displayId,hwc2_layer_t layerId)2267 std::tuple<HWC2On1Adapter::Layer*, Error> HWC2On1Adapter::getLayer(
2268 hwc2_display_t displayId, hwc2_layer_t layerId) {
2269 auto display = getDisplay(displayId);
2270 if (!display) {
2271 return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadDisplay);
2272 }
2273
2274 auto layerEntry = mLayers.find(layerId);
2275 if (layerEntry == mLayers.end()) {
2276 return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadLayer);
2277 }
2278
2279 auto layer = layerEntry->second;
2280 if (layer->getDisplay().getId() != displayId) {
2281 return std::make_tuple(static_cast<Layer*>(nullptr), Error::BadLayer);
2282 }
2283 return std::make_tuple(layer.get(), Error::None);
2284 }
2285
populatePrimary()2286 void HWC2On1Adapter::populatePrimary() {
2287 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2288
2289 auto display = std::make_shared<Display>(*this, HWC2::DisplayType::Physical);
2290 mHwc1DisplayMap[HWC_DISPLAY_PRIMARY] = display->getId();
2291 display->setHwc1Id(HWC_DISPLAY_PRIMARY);
2292 display->populateConfigs();
2293 mDisplays.emplace(display->getId(), std::move(display));
2294 }
2295
prepareAllDisplays()2296 bool HWC2On1Adapter::prepareAllDisplays() {
2297 ATRACE_CALL();
2298
2299 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2300
2301 for (const auto& displayPair : mDisplays) {
2302 auto& display = displayPair.second;
2303 if (!display->prepare()) {
2304 return false;
2305 }
2306 }
2307
2308 if (mHwc1DisplayMap.count(HWC_DISPLAY_PRIMARY) == 0) {
2309 ALOGE("prepareAllDisplays: Unable to find primary HWC1 display");
2310 return false;
2311 }
2312
2313 // Build an array of hwc_display_contents_1 to call prepare() on HWC1.
2314 mHwc1Contents.clear();
2315
2316 // Always push the primary display
2317 auto primaryDisplayId = mHwc1DisplayMap[HWC_DISPLAY_PRIMARY];
2318 auto& primaryDisplay = mDisplays[primaryDisplayId];
2319 mHwc1Contents.push_back(primaryDisplay->getDisplayContents());
2320
2321 // Push the external display, if present
2322 if (mHwc1DisplayMap.count(HWC_DISPLAY_EXTERNAL) != 0) {
2323 auto externalDisplayId = mHwc1DisplayMap[HWC_DISPLAY_EXTERNAL];
2324 auto& externalDisplay = mDisplays[externalDisplayId];
2325 mHwc1Contents.push_back(externalDisplay->getDisplayContents());
2326 } else {
2327 // Even if an external display isn't present, we still need to send
2328 // at least two displays down to HWC1
2329 mHwc1Contents.push_back(nullptr);
2330 }
2331
2332 // Push the hardware virtual display, if supported and present
2333 if (mHwc1MinorVersion >= 3) {
2334 if (mHwc1DisplayMap.count(HWC_DISPLAY_VIRTUAL) != 0) {
2335 auto virtualDisplayId = mHwc1DisplayMap[HWC_DISPLAY_VIRTUAL];
2336 auto& virtualDisplay = mDisplays[virtualDisplayId];
2337 mHwc1Contents.push_back(virtualDisplay->getDisplayContents());
2338 } else {
2339 mHwc1Contents.push_back(nullptr);
2340 }
2341 }
2342
2343 for (auto& displayContents : mHwc1Contents) {
2344 if (!displayContents) {
2345 continue;
2346 }
2347
2348 ALOGV("Display %zd layers:", mHwc1Contents.size() - 1);
2349 for (size_t l = 0; l < displayContents->numHwLayers; ++l) {
2350 auto& layer = displayContents->hwLayers[l];
2351 ALOGV(" %zd: %d", l, layer.compositionType);
2352 }
2353 }
2354
2355 ALOGV("Calling HWC1 prepare");
2356 {
2357 ATRACE_NAME("HWC1 prepare");
2358 mHwc1Device->prepare(mHwc1Device, mHwc1Contents.size(),
2359 mHwc1Contents.data());
2360 }
2361
2362 for (size_t c = 0; c < mHwc1Contents.size(); ++c) {
2363 auto& contents = mHwc1Contents[c];
2364 if (!contents) {
2365 continue;
2366 }
2367 ALOGV("Display %zd layers:", c);
2368 for (size_t l = 0; l < contents->numHwLayers; ++l) {
2369 ALOGV(" %zd: %d", l, contents->hwLayers[l].compositionType);
2370 }
2371 }
2372
2373 // Return the received contents to their respective displays
2374 for (size_t hwc1Id = 0; hwc1Id < mHwc1Contents.size(); ++hwc1Id) {
2375 if (mHwc1Contents[hwc1Id] == nullptr) {
2376 continue;
2377 }
2378
2379 auto displayId = mHwc1DisplayMap[hwc1Id];
2380 auto& display = mDisplays[displayId];
2381 display->generateChanges();
2382 }
2383
2384 return true;
2385 }
2386
dumpHWC1Message(hwc_composer_device_1 * device,size_t numDisplays,hwc_display_contents_1_t ** displays)2387 void dumpHWC1Message(hwc_composer_device_1* device, size_t numDisplays,
2388 hwc_display_contents_1_t** displays) {
2389 ALOGV("*****************************");
2390 size_t displayId = 0;
2391 while (displayId < numDisplays) {
2392 hwc_display_contents_1_t* display = displays[displayId];
2393
2394 ALOGV("hwc_display_contents_1_t[%zu] @0x%p", displayId, display);
2395 if (display == nullptr) {
2396 displayId++;
2397 continue;
2398 }
2399 ALOGV(" retirefd:0x%08x", display->retireFenceFd);
2400 ALOGV(" outbuf :0x%p", display->outbuf);
2401 ALOGV(" outbuffd:0x%08x", display->outbufAcquireFenceFd);
2402 ALOGV(" flags :0x%08x", display->flags);
2403 for(size_t layerId=0 ; layerId < display->numHwLayers ; layerId++) {
2404 hwc_layer_1_t& layer = display->hwLayers[layerId];
2405 ALOGV(" Layer[%zu]:", layerId);
2406 ALOGV(" composition : 0x%08x", layer.compositionType);
2407 ALOGV(" hints : 0x%08x", layer.hints);
2408 ALOGV(" flags : 0x%08x", layer.flags);
2409 ALOGV(" handle : 0x%p", layer.handle);
2410 ALOGV(" transform : 0x%08x", layer.transform);
2411 ALOGV(" blending : 0x%08x", layer.blending);
2412 ALOGV(" sourceCropf : %f, %f, %f, %f",
2413 layer.sourceCropf.left,
2414 layer.sourceCropf.top,
2415 layer.sourceCropf.right,
2416 layer.sourceCropf.bottom);
2417 ALOGV(" displayFrame : %d, %d, %d, %d",
2418 layer.displayFrame.left,
2419 layer.displayFrame.left,
2420 layer.displayFrame.left,
2421 layer.displayFrame.left);
2422 hwc_region_t& visReg = layer.visibleRegionScreen;
2423 ALOGV(" visibleRegionScreen: #0x%08zx[@0x%p]",
2424 visReg.numRects,
2425 visReg.rects);
2426 for (size_t visRegId=0; visRegId < visReg.numRects ; visRegId++) {
2427 if (layer.visibleRegionScreen.rects == nullptr) {
2428 ALOGV(" null");
2429 } else {
2430 ALOGV(" visibleRegionScreen[%zu] %d, %d, %d, %d",
2431 visRegId,
2432 visReg.rects[visRegId].left,
2433 visReg.rects[visRegId].top,
2434 visReg.rects[visRegId].right,
2435 visReg.rects[visRegId].bottom);
2436 }
2437 }
2438 ALOGV(" acquireFenceFd : 0x%08x", layer.acquireFenceFd);
2439 ALOGV(" releaseFenceFd : 0x%08x", layer.releaseFenceFd);
2440 ALOGV(" planeAlpha : 0x%08x", layer.planeAlpha);
2441 if (getMinorVersion(device) < 5)
2442 continue;
2443 ALOGV(" surfaceDamage : #0x%08zx[@0x%p]",
2444 layer.surfaceDamage.numRects,
2445 layer.surfaceDamage.rects);
2446 for (size_t sdId=0; sdId < layer.surfaceDamage.numRects ; sdId++) {
2447 if (layer.surfaceDamage.rects == nullptr) {
2448 ALOGV(" null");
2449 } else {
2450 ALOGV(" surfaceDamage[%zu] %d, %d, %d, %d",
2451 sdId,
2452 layer.surfaceDamage.rects[sdId].left,
2453 layer.surfaceDamage.rects[sdId].top,
2454 layer.surfaceDamage.rects[sdId].right,
2455 layer.surfaceDamage.rects[sdId].bottom);
2456 }
2457 }
2458 }
2459 displayId++;
2460 }
2461 ALOGV("-----------------------------");
2462 }
2463
setAllDisplays()2464 Error HWC2On1Adapter::setAllDisplays() {
2465 ATRACE_CALL();
2466
2467 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2468
2469 // Make sure we're ready to validate
2470 for (size_t hwc1Id = 0; hwc1Id < mHwc1Contents.size(); ++hwc1Id) {
2471 if (mHwc1Contents[hwc1Id] == nullptr) {
2472 continue;
2473 }
2474
2475 auto displayId = mHwc1DisplayMap[hwc1Id];
2476 auto& display = mDisplays[displayId];
2477 Error error = display->set(*mHwc1Contents[hwc1Id]);
2478 if (error != Error::None) {
2479 ALOGE("setAllDisplays: Failed to set display %zd: %s", hwc1Id,
2480 to_string(error).c_str());
2481 return error;
2482 }
2483 }
2484
2485 ALOGV("Calling HWC1 set");
2486 {
2487 ATRACE_NAME("HWC1 set");
2488 //dumpHWC1Message(mHwc1Device, mHwc1Contents.size(), mHwc1Contents.data());
2489 mHwc1Device->set(mHwc1Device, mHwc1Contents.size(),
2490 mHwc1Contents.data());
2491 }
2492
2493 // Add retire and release fences
2494 for (size_t hwc1Id = 0; hwc1Id < mHwc1Contents.size(); ++hwc1Id) {
2495 if (mHwc1Contents[hwc1Id] == nullptr) {
2496 continue;
2497 }
2498
2499 auto displayId = mHwc1DisplayMap[hwc1Id];
2500 auto& display = mDisplays[displayId];
2501 auto retireFenceFd = mHwc1Contents[hwc1Id]->retireFenceFd;
2502 ALOGV("setAllDisplays: Adding retire fence %d to display %zd",
2503 retireFenceFd, hwc1Id);
2504 display->addRetireFence(mHwc1Contents[hwc1Id]->retireFenceFd);
2505 display->addReleaseFences(*mHwc1Contents[hwc1Id]);
2506 }
2507
2508 return Error::None;
2509 }
2510
hwc1Invalidate()2511 void HWC2On1Adapter::hwc1Invalidate() {
2512 ALOGV("Received hwc1Invalidate");
2513
2514 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2515
2516 // If the HWC2-side callback hasn't been registered yet, buffer this until
2517 // it is registered.
2518 if (mCallbacks.count(Callback::Refresh) == 0) {
2519 mHasPendingInvalidate = true;
2520 return;
2521 }
2522
2523 const auto& callbackInfo = mCallbacks[Callback::Refresh];
2524 std::vector<hwc2_display_t> displays;
2525 for (const auto& displayPair : mDisplays) {
2526 displays.emplace_back(displayPair.first);
2527 }
2528
2529 // Call back without the state lock held.
2530 lock.unlock();
2531
2532 auto refresh = reinterpret_cast<HWC2_PFN_REFRESH>(callbackInfo.pointer);
2533 for (auto display : displays) {
2534 refresh(callbackInfo.data, display);
2535 }
2536 }
2537
hwc1Vsync(int hwc1DisplayId,int64_t timestamp)2538 void HWC2On1Adapter::hwc1Vsync(int hwc1DisplayId, int64_t timestamp) {
2539 ALOGV("Received hwc1Vsync(%d, %" PRId64 ")", hwc1DisplayId, timestamp);
2540
2541 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2542
2543 // If the HWC2-side callback hasn't been registered yet, buffer this until
2544 // it is registered.
2545 if (mCallbacks.count(Callback::Vsync) == 0) {
2546 mPendingVsyncs.emplace_back(hwc1DisplayId, timestamp);
2547 return;
2548 }
2549
2550 if (mHwc1DisplayMap.count(hwc1DisplayId) == 0) {
2551 ALOGE("hwc1Vsync: Couldn't find display for HWC1 id %d", hwc1DisplayId);
2552 return;
2553 }
2554
2555 const auto& callbackInfo = mCallbacks[Callback::Vsync];
2556 auto displayId = mHwc1DisplayMap[hwc1DisplayId];
2557
2558 // Call back without the state lock held.
2559 lock.unlock();
2560
2561 auto vsync = reinterpret_cast<HWC2_PFN_VSYNC>(callbackInfo.pointer);
2562 vsync(callbackInfo.data, displayId, timestamp);
2563 }
2564
hwc1Hotplug(int hwc1DisplayId,int connected)2565 void HWC2On1Adapter::hwc1Hotplug(int hwc1DisplayId, int connected) {
2566 ALOGV("Received hwc1Hotplug(%d, %d)", hwc1DisplayId, connected);
2567
2568 if (hwc1DisplayId != HWC_DISPLAY_EXTERNAL) {
2569 ALOGE("hwc1Hotplug: Received hotplug for non-external display");
2570 return;
2571 }
2572
2573 std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex);
2574
2575 // If the HWC2-side callback hasn't been registered yet, buffer this until
2576 // it is registered
2577 if (mCallbacks.count(Callback::Hotplug) == 0) {
2578 mPendingHotplugs.emplace_back(hwc1DisplayId, connected);
2579 return;
2580 }
2581
2582 hwc2_display_t displayId = UINT64_MAX;
2583 if (mHwc1DisplayMap.count(hwc1DisplayId) == 0) {
2584 if (connected == 0) {
2585 ALOGW("hwc1Hotplug: Received disconnect for unconnected display");
2586 return;
2587 }
2588
2589 // Create a new display on connect
2590 auto display = std::make_shared<HWC2On1Adapter::Display>(*this,
2591 HWC2::DisplayType::Physical);
2592 display->setHwc1Id(HWC_DISPLAY_EXTERNAL);
2593 display->populateConfigs();
2594 displayId = display->getId();
2595 mHwc1DisplayMap[HWC_DISPLAY_EXTERNAL] = displayId;
2596 mDisplays.emplace(displayId, std::move(display));
2597 } else {
2598 if (connected != 0) {
2599 ALOGW("hwc1Hotplug: Received connect for previously connected "
2600 "display");
2601 return;
2602 }
2603
2604 // Disconnect an existing display
2605 displayId = mHwc1DisplayMap[hwc1DisplayId];
2606 mHwc1DisplayMap.erase(HWC_DISPLAY_EXTERNAL);
2607 mDisplays.erase(displayId);
2608 }
2609
2610 const auto& callbackInfo = mCallbacks[Callback::Hotplug];
2611
2612 // Call back without the state lock held
2613 lock.unlock();
2614
2615 auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(callbackInfo.pointer);
2616 auto hwc2Connected = (connected == 0) ?
2617 HWC2::Connection::Disconnected : HWC2::Connection::Connected;
2618 hotplug(callbackInfo.data, displayId, static_cast<int32_t>(hwc2Connected));
2619 }
2620 } // namespace android
2621