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