HWComposer.cpp revision 06d63de03cb2a551ca99608f5aa0c4f3e200b0fc
1/* 2 * Copyright (C) 2010 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 "HWComposer" 21#define ATRACE_TAG ATRACE_TAG_GRAPHICS 22 23#include <inttypes.h> 24#include <math.h> 25#include <stdint.h> 26#include <stdio.h> 27#include <stdlib.h> 28#include <string.h> 29#include <sys/types.h> 30 31#include <utils/Errors.h> 32#include <utils/misc.h> 33#include <utils/NativeHandle.h> 34#include <utils/String8.h> 35#include <utils/Thread.h> 36#include <utils/Trace.h> 37#include <utils/Vector.h> 38 39#include <ui/GraphicBuffer.h> 40 41#include <hardware/hardware.h> 42#include <hardware/hwcomposer.h> 43 44#include <android/configuration.h> 45 46#include <cutils/properties.h> 47#include <log/log.h> 48 49#include "HWComposer.h" 50#include "HWC2On1Adapter.h" 51#include "HWC2.h" 52 53#include "../Layer.h" // needed only for debugging 54#include "../SurfaceFlinger.h" 55 56namespace android { 57 58#define MIN_HWC_HEADER_VERSION HWC_HEADER_VERSION 59 60// --------------------------------------------------------------------------- 61 62HWComposer::HWComposer(const sp<SurfaceFlinger>& flinger) 63 : mFlinger(flinger), 64 mAdapter(), 65 mHwcDevice(), 66 mDisplayData(2), 67 mFreeDisplaySlots(), 68 mHwcDisplaySlots(), 69 mCBContext(), 70 mEventHandler(nullptr), 71 mVSyncCounts(), 72 mRemainingHwcVirtualDisplays(0) 73{ 74 for (size_t i=0 ; i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) { 75 mLastHwVSync[i] = 0; 76 mVSyncCounts[i] = 0; 77 } 78 79 loadHwcModule(); 80} 81 82HWComposer::~HWComposer() {} 83 84void HWComposer::setEventHandler(EventHandler* handler) 85{ 86 if (handler == nullptr) { 87 ALOGE("setEventHandler: Rejected attempt to clear handler"); 88 return; 89 } 90 91 bool wasNull = (mEventHandler == nullptr); 92 mEventHandler = handler; 93 94 if (wasNull) { 95 auto hotplugHook = std::bind(&HWComposer::hotplug, this, 96 std::placeholders::_1, std::placeholders::_2); 97 mHwcDevice->registerHotplugCallback(hotplugHook); 98 auto invalidateHook = std::bind(&HWComposer::invalidate, this, 99 std::placeholders::_1); 100 mHwcDevice->registerRefreshCallback(invalidateHook); 101 auto vsyncHook = std::bind(&HWComposer::vsync, this, 102 std::placeholders::_1, std::placeholders::_2); 103 mHwcDevice->registerVsyncCallback(vsyncHook); 104 } 105} 106 107// Load and prepare the hardware composer module. Sets mHwc. 108void HWComposer::loadHwcModule() 109{ 110 ALOGV("loadHwcModule"); 111 112#ifdef BYPASS_IHWC 113 hw_module_t const* module; 114 115 if (hw_get_module(HWC_HARDWARE_MODULE_ID, &module) != 0) { 116 ALOGE("%s module not found, aborting", HWC_HARDWARE_MODULE_ID); 117 abort(); 118 } 119 120 hw_device_t* device = nullptr; 121 int error = module->methods->open(module, HWC_HARDWARE_COMPOSER, &device); 122 if (error != 0) { 123 ALOGE("Failed to open HWC device (%s), aborting", strerror(-error)); 124 abort(); 125 } 126 127 uint32_t majorVersion = (device->version >> 24) & 0xF; 128 if (majorVersion == 2) { 129 mHwcDevice = std::make_unique<HWC2::Device>( 130 reinterpret_cast<hwc2_device_t*>(device)); 131 } else { 132 mAdapter = std::make_unique<HWC2On1Adapter>( 133 reinterpret_cast<hwc_composer_device_1_t*>(device)); 134 uint8_t minorVersion = mAdapter->getHwc1MinorVersion(); 135 if (minorVersion < 1) { 136 ALOGE("Cannot adapt to HWC version %d.%d", 137 static_cast<int32_t>((minorVersion >> 8) & 0xF), 138 static_cast<int32_t>(minorVersion & 0xF)); 139 abort(); 140 } 141 mHwcDevice = std::make_unique<HWC2::Device>( 142 static_cast<hwc2_device_t*>(mAdapter.get())); 143 } 144#else 145 mHwcDevice = std::make_unique<HWC2::Device>(); 146#endif 147 148 mRemainingHwcVirtualDisplays = mHwcDevice->getMaxVirtualDisplayCount(); 149} 150 151bool HWComposer::hasCapability(HWC2::Capability capability) const 152{ 153 return mHwcDevice->getCapabilities().count(capability) > 0; 154} 155 156bool HWComposer::isValidDisplay(int32_t displayId) const { 157 return static_cast<size_t>(displayId) < mDisplayData.size() && 158 mDisplayData[displayId].hwcDisplay; 159} 160 161void HWComposer::validateChange(HWC2::Composition from, HWC2::Composition to) { 162 bool valid = true; 163 switch (from) { 164 case HWC2::Composition::Client: 165 valid = false; 166 break; 167 case HWC2::Composition::Device: 168 case HWC2::Composition::SolidColor: 169 valid = (to == HWC2::Composition::Client); 170 break; 171 case HWC2::Composition::Cursor: 172 case HWC2::Composition::Sideband: 173 valid = (to == HWC2::Composition::Client || 174 to == HWC2::Composition::Device); 175 break; 176 default: 177 break; 178 } 179 180 if (!valid) { 181 ALOGE("Invalid layer type change: %s --> %s", to_string(from).c_str(), 182 to_string(to).c_str()); 183 } 184} 185 186void HWComposer::hotplug(const std::shared_ptr<HWC2::Display>& display, 187 HWC2::Connection connected) { 188 ALOGV("hotplug: %" PRIu64 ", %s", display->getId(), 189 to_string(connected).c_str()); 190 int32_t disp = 0; 191 if (!mDisplayData[0].hwcDisplay) { 192 ALOGE_IF(connected != HWC2::Connection::Connected, "Assumed primary" 193 " display would be connected"); 194 mDisplayData[0].hwcDisplay = display; 195 mHwcDisplaySlots[display->getId()] = 0; 196 disp = DisplayDevice::DISPLAY_PRIMARY; 197 } else { 198 // Disconnect is handled through HWComposer::disconnectDisplay via 199 // SurfaceFlinger's onHotplugReceived callback handling 200 if (connected == HWC2::Connection::Connected) { 201 mDisplayData[1].hwcDisplay = display; 202 mHwcDisplaySlots[display->getId()] = 1; 203 } 204 disp = DisplayDevice::DISPLAY_EXTERNAL; 205 } 206 mEventHandler->onHotplugReceived(disp, 207 connected == HWC2::Connection::Connected); 208} 209 210void HWComposer::invalidate(const std::shared_ptr<HWC2::Display>& /*display*/) { 211 mFlinger->repaintEverything(); 212} 213 214void HWComposer::vsync(const std::shared_ptr<HWC2::Display>& display, 215 int64_t timestamp) { 216 auto displayType = HWC2::DisplayType::Invalid; 217 auto error = display->getType(&displayType); 218 if (error != HWC2::Error::None) { 219 ALOGE("vsync: Failed to determine type of display %" PRIu64, 220 display->getId()); 221 return; 222 } 223 224 if (displayType == HWC2::DisplayType::Virtual) { 225 ALOGE("Virtual display %" PRIu64 " passed to vsync callback", 226 display->getId()); 227 return; 228 } 229 230 if (mHwcDisplaySlots.count(display->getId()) == 0) { 231 ALOGE("Unknown physical display %" PRIu64 " passed to vsync callback", 232 display->getId()); 233 return; 234 } 235 236 int32_t disp = mHwcDisplaySlots[display->getId()]; 237 { 238 Mutex::Autolock _l(mLock); 239 240 // There have been reports of HWCs that signal several vsync events 241 // with the same timestamp when turning the display off and on. This 242 // is a bug in the HWC implementation, but filter the extra events 243 // out here so they don't cause havoc downstream. 244 if (timestamp == mLastHwVSync[disp]) { 245 ALOGW("Ignoring duplicate VSYNC event from HWC (t=%" PRId64 ")", 246 timestamp); 247 return; 248 } 249 250 mLastHwVSync[disp] = timestamp; 251 } 252 253 char tag[16]; 254 snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp); 255 ATRACE_INT(tag, ++mVSyncCounts[disp] & 1); 256 257 mEventHandler->onVSyncReceived(disp, timestamp); 258} 259 260status_t HWComposer::allocateVirtualDisplay(uint32_t width, uint32_t height, 261 android_pixel_format_t* format, int32_t *outId) { 262 if (mRemainingHwcVirtualDisplays == 0) { 263 ALOGE("allocateVirtualDisplay: No remaining virtual displays"); 264 return NO_MEMORY; 265 } 266 267 std::shared_ptr<HWC2::Display> display; 268 auto error = mHwcDevice->createVirtualDisplay(width, height, format, 269 &display); 270 if (error != HWC2::Error::None) { 271 ALOGE("allocateVirtualDisplay: Failed to create HWC virtual display"); 272 return NO_MEMORY; 273 } 274 275 size_t displaySlot = 0; 276 if (!mFreeDisplaySlots.empty()) { 277 displaySlot = *mFreeDisplaySlots.begin(); 278 mFreeDisplaySlots.erase(displaySlot); 279 } else if (mDisplayData.size() < INT32_MAX) { 280 // Don't bother allocating a slot larger than we can return 281 displaySlot = mDisplayData.size(); 282 mDisplayData.resize(displaySlot + 1); 283 } else { 284 ALOGE("allocateVirtualDisplay: Unable to allocate a display slot"); 285 return NO_MEMORY; 286 } 287 288 mDisplayData[displaySlot].hwcDisplay = display; 289 290 --mRemainingHwcVirtualDisplays; 291 *outId = static_cast<int32_t>(displaySlot); 292 293 return NO_ERROR; 294} 295 296std::shared_ptr<HWC2::Layer> HWComposer::createLayer(int32_t displayId) { 297 if (!isValidDisplay(displayId)) { 298 ALOGE("Failed to create layer on invalid display %d", displayId); 299 return nullptr; 300 } 301 auto display = mDisplayData[displayId].hwcDisplay; 302 std::shared_ptr<HWC2::Layer> layer; 303 auto error = display->createLayer(&layer); 304 if (error != HWC2::Error::None) { 305 ALOGE("Failed to create layer on display %d: %s (%d)", displayId, 306 to_string(error).c_str(), static_cast<int32_t>(error)); 307 return nullptr; 308 } 309 return layer; 310} 311 312nsecs_t HWComposer::getRefreshTimestamp(int32_t displayId) const { 313 // this returns the last refresh timestamp. 314 // if the last one is not available, we estimate it based on 315 // the refresh period and whatever closest timestamp we have. 316 Mutex::Autolock _l(mLock); 317 nsecs_t now = systemTime(CLOCK_MONOTONIC); 318 auto vsyncPeriod = getActiveConfig(displayId)->getVsyncPeriod(); 319 return now - ((now - mLastHwVSync[displayId]) % vsyncPeriod); 320} 321 322bool HWComposer::isConnected(int32_t displayId) const { 323 if (!isValidDisplay(displayId)) { 324 ALOGE("isConnected: Attempted to access invalid display %d", displayId); 325 return false; 326 } 327 return mDisplayData[displayId].hwcDisplay->isConnected(); 328} 329 330std::vector<std::shared_ptr<const HWC2::Display::Config>> 331 HWComposer::getConfigs(int32_t displayId) const { 332 if (!isValidDisplay(displayId)) { 333 ALOGE("getConfigs: Attempted to access invalid display %d", displayId); 334 return {}; 335 } 336 auto& displayData = mDisplayData[displayId]; 337 auto configs = mDisplayData[displayId].hwcDisplay->getConfigs(); 338 if (displayData.configMap.empty()) { 339 for (size_t i = 0; i < configs.size(); ++i) { 340 displayData.configMap[i] = configs[i]; 341 } 342 } 343 return configs; 344} 345 346std::shared_ptr<const HWC2::Display::Config> 347 HWComposer::getActiveConfig(int32_t displayId) const { 348 if (!isValidDisplay(displayId)) { 349 ALOGV("getActiveConfigs: Attempted to access invalid display %d", 350 displayId); 351 return nullptr; 352 } 353 std::shared_ptr<const HWC2::Display::Config> config; 354 auto error = mDisplayData[displayId].hwcDisplay->getActiveConfig(&config); 355 if (error == HWC2::Error::BadConfig) { 356 ALOGE("getActiveConfig: No config active, returning null"); 357 return nullptr; 358 } else if (error != HWC2::Error::None) { 359 ALOGE("getActiveConfig failed for display %d: %s (%d)", displayId, 360 to_string(error).c_str(), static_cast<int32_t>(error)); 361 return nullptr; 362 } else if (!config) { 363 ALOGE("getActiveConfig returned an unknown config for display %d", 364 displayId); 365 return nullptr; 366 } 367 368 return config; 369} 370 371std::vector<android_color_mode_t> HWComposer::getColorModes(int32_t displayId) const { 372 std::vector<android_color_mode_t> modes; 373 374 if (!isValidDisplay(displayId)) { 375 ALOGE("getColorModes: Attempted to access invalid display %d", 376 displayId); 377 return modes; 378 } 379 const std::shared_ptr<HWC2::Display>& hwcDisplay = 380 mDisplayData[displayId].hwcDisplay; 381 382 auto error = hwcDisplay->getColorModes(&modes); 383 if (error != HWC2::Error::None) { 384 ALOGE("getColorModes failed for display %d: %s (%d)", displayId, 385 to_string(error).c_str(), static_cast<int32_t>(error)); 386 return std::vector<android_color_mode_t>(); 387 } 388 389 return modes; 390} 391 392status_t HWComposer::setActiveColorMode(int32_t displayId, android_color_mode_t mode) { 393 if (!isValidDisplay(displayId)) { 394 ALOGE("setActiveColorMode: Display %d is not valid", displayId); 395 return BAD_INDEX; 396 } 397 398 auto& displayData = mDisplayData[displayId]; 399 auto error = displayData.hwcDisplay->setColorMode(mode); 400 if (error != HWC2::Error::None) { 401 ALOGE("setActiveConfig: Failed to set color mode %d on display %d: " 402 "%s (%d)", mode, displayId, to_string(error).c_str(), 403 static_cast<int32_t>(error)); 404 return UNKNOWN_ERROR; 405 } 406 407 return NO_ERROR; 408} 409 410 411void HWComposer::setVsyncEnabled(int32_t displayId, HWC2::Vsync enabled) { 412 if (displayId < 0 || displayId >= HWC_DISPLAY_VIRTUAL) { 413 ALOGD("setVsyncEnabled: Ignoring for virtual display %d", displayId); 414 return; 415 } 416 417 if (!isValidDisplay(displayId)) { 418 ALOGE("setVsyncEnabled: Attempted to access invalid display %d", 419 displayId); 420 return; 421 } 422 423 // NOTE: we use our own internal lock here because we have to call 424 // into the HWC with the lock held, and we want to make sure 425 // that even if HWC blocks (which it shouldn't), it won't 426 // affect other threads. 427 Mutex::Autolock _l(mVsyncLock); 428 auto& displayData = mDisplayData[displayId]; 429 if (enabled != displayData.vsyncEnabled) { 430 ATRACE_CALL(); 431 auto error = displayData.hwcDisplay->setVsyncEnabled(enabled); 432 if (error == HWC2::Error::None) { 433 displayData.vsyncEnabled = enabled; 434 435 char tag[16]; 436 snprintf(tag, sizeof(tag), "HW_VSYNC_ON_%1u", displayId); 437 ATRACE_INT(tag, enabled == HWC2::Vsync::Enable ? 1 : 0); 438 } else { 439 ALOGE("setVsyncEnabled: Failed to set vsync to %s on %d/%" PRIu64 440 ": %s (%d)", to_string(enabled).c_str(), displayId, 441 mDisplayData[displayId].hwcDisplay->getId(), 442 to_string(error).c_str(), static_cast<int32_t>(error)); 443 } 444 } 445} 446 447status_t HWComposer::setClientTarget(int32_t displayId, uint32_t slot, 448 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target, 449 android_dataspace_t dataspace) { 450 if (!isValidDisplay(displayId)) { 451 return BAD_INDEX; 452 } 453 454 ALOGV("setClientTarget for display %d", displayId); 455 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay; 456 buffer_handle_t handle = nullptr; 457 if ((target != nullptr) && target->getNativeBuffer()) { 458 handle = target->getNativeBuffer()->handle; 459 } 460 auto error = hwcDisplay->setClientTarget(slot, handle, 461 acquireFence, dataspace); 462 if (error != HWC2::Error::None) { 463 ALOGE("Failed to set client target for display %d: %s (%d)", displayId, 464 to_string(error).c_str(), static_cast<int32_t>(error)); 465 return BAD_VALUE; 466 } 467 468 return NO_ERROR; 469} 470 471status_t HWComposer::prepare(DisplayDevice& displayDevice) { 472 ATRACE_CALL(); 473 474 Mutex::Autolock _l(mDisplayLock); 475 auto displayId = displayDevice.getHwcDisplayId(); 476 if (displayId == DisplayDevice::DISPLAY_ID_INVALID) { 477 ALOGV("Skipping HWComposer prepare for non-HWC display"); 478 return NO_ERROR; 479 } 480 if (!isValidDisplay(displayId)) { 481 return BAD_INDEX; 482 } 483 484 auto& displayData = mDisplayData[displayId]; 485 auto& hwcDisplay = displayData.hwcDisplay; 486 if (!hwcDisplay->isConnected()) { 487 return NO_ERROR; 488 } 489 490 uint32_t numTypes = 0; 491 uint32_t numRequests = 0; 492 auto error = hwcDisplay->validate(&numTypes, &numRequests); 493 if (error != HWC2::Error::None && error != HWC2::Error::HasChanges) { 494 ALOGE("prepare: validate failed for display %d: %s (%d)", displayId, 495 to_string(error).c_str(), static_cast<int32_t>(error)); 496 return BAD_INDEX; 497 } 498 499 std::unordered_map<std::shared_ptr<HWC2::Layer>, HWC2::Composition> 500 changedTypes; 501 changedTypes.reserve(numTypes); 502 error = hwcDisplay->getChangedCompositionTypes(&changedTypes); 503 if (error != HWC2::Error::None) { 504 ALOGE("prepare: getChangedCompositionTypes failed on display %d: " 505 "%s (%d)", displayId, to_string(error).c_str(), 506 static_cast<int32_t>(error)); 507 return BAD_INDEX; 508 } 509 510 511 displayData.displayRequests = static_cast<HWC2::DisplayRequest>(0); 512 std::unordered_map<std::shared_ptr<HWC2::Layer>, HWC2::LayerRequest> 513 layerRequests; 514 layerRequests.reserve(numRequests); 515 error = hwcDisplay->getRequests(&displayData.displayRequests, 516 &layerRequests); 517 if (error != HWC2::Error::None) { 518 ALOGE("prepare: getRequests failed on display %d: %s (%d)", displayId, 519 to_string(error).c_str(), static_cast<int32_t>(error)); 520 return BAD_INDEX; 521 } 522 523 displayData.hasClientComposition = false; 524 displayData.hasDeviceComposition = false; 525 for (auto& layer : displayDevice.getVisibleLayersSortedByZ()) { 526 auto hwcLayer = layer->getHwcLayer(displayId); 527 528 if (changedTypes.count(hwcLayer) != 0) { 529 // We pass false so we only update our state and don't call back 530 // into the HWC device 531 validateChange(layer->getCompositionType(displayId), 532 changedTypes[hwcLayer]); 533 layer->setCompositionType(displayId, changedTypes[hwcLayer], false); 534 } 535 536 switch (layer->getCompositionType(displayId)) { 537 case HWC2::Composition::Client: 538 displayData.hasClientComposition = true; 539 break; 540 case HWC2::Composition::Device: 541 case HWC2::Composition::SolidColor: 542 case HWC2::Composition::Cursor: 543 case HWC2::Composition::Sideband: 544 displayData.hasDeviceComposition = true; 545 break; 546 default: 547 break; 548 } 549 550 if (layerRequests.count(hwcLayer) != 0 && 551 layerRequests[hwcLayer] == 552 HWC2::LayerRequest::ClearClientTarget) { 553 layer->setClearClientTarget(displayId, true); 554 } else { 555 if (layerRequests.count(hwcLayer) != 0) { 556 ALOGE("prepare: Unknown layer request: %s", 557 to_string(layerRequests[hwcLayer]).c_str()); 558 } 559 layer->setClearClientTarget(displayId, false); 560 } 561 } 562 563 error = hwcDisplay->acceptChanges(); 564 if (error != HWC2::Error::None) { 565 ALOGE("prepare: acceptChanges failed: %s", to_string(error).c_str()); 566 return BAD_INDEX; 567 } 568 569 return NO_ERROR; 570} 571 572bool HWComposer::hasDeviceComposition(int32_t displayId) const { 573 if (displayId == DisplayDevice::DISPLAY_ID_INVALID) { 574 // Displays without a corresponding HWC display are never composed by 575 // the device 576 return false; 577 } 578 if (!isValidDisplay(displayId)) { 579 ALOGE("hasDeviceComposition: Invalid display %d", displayId); 580 return false; 581 } 582 return mDisplayData[displayId].hasDeviceComposition; 583} 584 585bool HWComposer::hasClientComposition(int32_t displayId) const { 586 if (displayId == DisplayDevice::DISPLAY_ID_INVALID) { 587 // Displays without a corresponding HWC display are always composed by 588 // the client 589 return true; 590 } 591 if (!isValidDisplay(displayId)) { 592 ALOGE("hasClientComposition: Invalid display %d", displayId); 593 return true; 594 } 595 return mDisplayData[displayId].hasClientComposition; 596} 597 598sp<Fence> HWComposer::getPresentFence(int32_t displayId) const { 599 if (!isValidDisplay(displayId)) { 600 ALOGE("getPresentFence failed for invalid display %d", displayId); 601 return Fence::NO_FENCE; 602 } 603 return mDisplayData[displayId].lastPresentFence; 604} 605 606bool HWComposer::presentFenceRepresentsStartOfScanout() const { 607 return mAdapter ? false : true; 608} 609 610sp<Fence> HWComposer::getLayerReleaseFence(int32_t displayId, 611 const std::shared_ptr<HWC2::Layer>& layer) const { 612 if (!isValidDisplay(displayId)) { 613 ALOGE("getLayerReleaseFence: Invalid display"); 614 return Fence::NO_FENCE; 615 } 616 auto displayFences = mDisplayData[displayId].releaseFences; 617 if (displayFences.count(layer) == 0) { 618 ALOGV("getLayerReleaseFence: Release fence not found"); 619 return Fence::NO_FENCE; 620 } 621 return displayFences[layer]; 622} 623 624status_t HWComposer::presentAndGetReleaseFences(int32_t displayId) { 625 ATRACE_CALL(); 626 627 if (!isValidDisplay(displayId)) { 628 return BAD_INDEX; 629 } 630 631 auto& displayData = mDisplayData[displayId]; 632 auto& hwcDisplay = displayData.hwcDisplay; 633 auto error = hwcDisplay->present(&displayData.lastPresentFence); 634 if (error != HWC2::Error::None) { 635 ALOGE("presentAndGetReleaseFences: failed for display %d: %s (%d)", 636 displayId, to_string(error).c_str(), static_cast<int32_t>(error)); 637 return UNKNOWN_ERROR; 638 } 639 640 std::unordered_map<std::shared_ptr<HWC2::Layer>, sp<Fence>> releaseFences; 641 error = hwcDisplay->getReleaseFences(&releaseFences); 642 if (error != HWC2::Error::None) { 643 ALOGE("presentAndGetReleaseFences: Failed to get release fences " 644 "for display %d: %s (%d)", 645 displayId, to_string(error).c_str(), 646 static_cast<int32_t>(error)); 647 return UNKNOWN_ERROR; 648 } 649 650 displayData.releaseFences = std::move(releaseFences); 651 652 return NO_ERROR; 653} 654 655status_t HWComposer::setPowerMode(int32_t displayId, int32_t intMode) { 656 ALOGV("setPowerMode(%d, %d)", displayId, intMode); 657 if (!isValidDisplay(displayId)) { 658 ALOGE("setPowerMode: Bad display"); 659 return BAD_INDEX; 660 } 661 if (displayId >= VIRTUAL_DISPLAY_ID_BASE) { 662 ALOGE("setPowerMode: Virtual display %d passed in, returning", 663 displayId); 664 return BAD_INDEX; 665 } 666 667 auto mode = static_cast<HWC2::PowerMode>(intMode); 668 if (mode == HWC2::PowerMode::Off) { 669 setVsyncEnabled(displayId, HWC2::Vsync::Disable); 670 } 671 672 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay; 673 switch (mode) { 674 case HWC2::PowerMode::Off: 675 case HWC2::PowerMode::On: 676 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str()); 677 { 678 auto error = hwcDisplay->setPowerMode(mode); 679 if (error != HWC2::Error::None) { 680 ALOGE("setPowerMode: Unable to set power mode %s for " 681 "display %d: %s (%d)", to_string(mode).c_str(), 682 displayId, to_string(error).c_str(), 683 static_cast<int32_t>(error)); 684 } 685 } 686 break; 687 case HWC2::PowerMode::Doze: 688 case HWC2::PowerMode::DozeSuspend: 689 ALOGV("setPowerMode: Calling HWC %s", to_string(mode).c_str()); 690 { 691 bool supportsDoze = false; 692 auto error = hwcDisplay->supportsDoze(&supportsDoze); 693 if (error != HWC2::Error::None) { 694 ALOGE("setPowerMode: Unable to query doze support for " 695 "display %d: %s (%d)", displayId, 696 to_string(error).c_str(), 697 static_cast<int32_t>(error)); 698 } 699 if (!supportsDoze) { 700 mode = HWC2::PowerMode::On; 701 } 702 703 error = hwcDisplay->setPowerMode(mode); 704 if (error != HWC2::Error::None) { 705 ALOGE("setPowerMode: Unable to set power mode %s for " 706 "display %d: %s (%d)", to_string(mode).c_str(), 707 displayId, to_string(error).c_str(), 708 static_cast<int32_t>(error)); 709 } 710 } 711 break; 712 default: 713 ALOGV("setPowerMode: Not calling HWC"); 714 break; 715 } 716 717 return NO_ERROR; 718} 719 720status_t HWComposer::setActiveConfig(int32_t displayId, size_t configId) { 721 if (!isValidDisplay(displayId)) { 722 ALOGE("setActiveConfig: Display %d is not valid", displayId); 723 return BAD_INDEX; 724 } 725 726 auto& displayData = mDisplayData[displayId]; 727 if (displayData.configMap.count(configId) == 0) { 728 ALOGE("setActiveConfig: Invalid config %zd", configId); 729 return BAD_INDEX; 730 } 731 732 auto error = displayData.hwcDisplay->setActiveConfig( 733 displayData.configMap[configId]); 734 if (error != HWC2::Error::None) { 735 ALOGE("setActiveConfig: Failed to set config %zu on display %d: " 736 "%s (%d)", configId, displayId, to_string(error).c_str(), 737 static_cast<int32_t>(error)); 738 return UNKNOWN_ERROR; 739 } 740 741 return NO_ERROR; 742} 743 744status_t HWComposer::setColorTransform(int32_t displayId, 745 const mat4& transform) { 746 if (!isValidDisplay(displayId)) { 747 ALOGE("setColorTransform: Display %d is not valid", displayId); 748 return BAD_INDEX; 749 } 750 751 auto& displayData = mDisplayData[displayId]; 752 bool isIdentity = transform == mat4(); 753 auto error = displayData.hwcDisplay->setColorTransform(transform, 754 isIdentity ? HAL_COLOR_TRANSFORM_IDENTITY : 755 HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX); 756 if (error != HWC2::Error::None) { 757 ALOGE("setColorTransform: Failed to set transform on display %d: " 758 "%s (%d)", displayId, to_string(error).c_str(), 759 static_cast<int32_t>(error)); 760 return UNKNOWN_ERROR; 761 } 762 763 return NO_ERROR; 764} 765 766void HWComposer::disconnectDisplay(int displayId) { 767 LOG_ALWAYS_FATAL_IF(displayId < 0); 768 auto& displayData = mDisplayData[displayId]; 769 770 auto displayType = HWC2::DisplayType::Invalid; 771 auto error = displayData.hwcDisplay->getType(&displayType); 772 if (error != HWC2::Error::None) { 773 ALOGE("disconnectDisplay: Failed to determine type of display %d", 774 displayId); 775 return; 776 } 777 778 // If this was a virtual display, add its slot back for reuse by future 779 // virtual displays 780 if (displayType == HWC2::DisplayType::Virtual) { 781 mFreeDisplaySlots.insert(displayId); 782 ++mRemainingHwcVirtualDisplays; 783 } 784 785 auto hwcId = displayData.hwcDisplay->getId(); 786 mHwcDisplaySlots.erase(hwcId); 787 displayData.reset(); 788} 789 790status_t HWComposer::setOutputBuffer(int32_t displayId, 791 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buffer) { 792 if (!isValidDisplay(displayId)) { 793 ALOGE("setOutputBuffer: Display %d is not valid", displayId); 794 return BAD_INDEX; 795 } 796 797 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay; 798 auto displayType = HWC2::DisplayType::Invalid; 799 auto error = hwcDisplay->getType(&displayType); 800 if (error != HWC2::Error::None) { 801 ALOGE("setOutputBuffer: Failed to determine type of display %d", 802 displayId); 803 return NAME_NOT_FOUND; 804 } 805 806 if (displayType != HWC2::DisplayType::Virtual) { 807 ALOGE("setOutputBuffer: Display %d is not virtual", displayId); 808 return INVALID_OPERATION; 809 } 810 811 error = hwcDisplay->setOutputBuffer(buffer, acquireFence); 812 if (error != HWC2::Error::None) { 813 ALOGE("setOutputBuffer: Failed to set buffer on display %d: %s (%d)", 814 displayId, to_string(error).c_str(), 815 static_cast<int32_t>(error)); 816 return UNKNOWN_ERROR; 817 } 818 819 return NO_ERROR; 820} 821 822void HWComposer::clearReleaseFences(int32_t displayId) { 823 if (!isValidDisplay(displayId)) { 824 ALOGE("clearReleaseFences: Display %d is not valid", displayId); 825 return; 826 } 827 mDisplayData[displayId].releaseFences.clear(); 828} 829 830std::unique_ptr<HdrCapabilities> HWComposer::getHdrCapabilities( 831 int32_t displayId) { 832 if (!isValidDisplay(displayId)) { 833 ALOGE("getHdrCapabilities: Display %d is not valid", displayId); 834 return nullptr; 835 } 836 837 auto& hwcDisplay = mDisplayData[displayId].hwcDisplay; 838 std::unique_ptr<HdrCapabilities> capabilities; 839 auto error = hwcDisplay->getHdrCapabilities(&capabilities); 840 if (error != HWC2::Error::None) { 841 ALOGE("getOutputCapabilities: Failed to get capabilities on display %d:" 842 " %s (%d)", displayId, to_string(error).c_str(), 843 static_cast<int32_t>(error)); 844 return nullptr; 845 } 846 847 return capabilities; 848} 849 850// Converts a PixelFormat to a human-readable string. Max 11 chars. 851// (Could use a table of prefab String8 objects.) 852/* 853static String8 getFormatStr(PixelFormat format) { 854 switch (format) { 855 case PIXEL_FORMAT_RGBA_8888: return String8("RGBA_8888"); 856 case PIXEL_FORMAT_RGBX_8888: return String8("RGBx_8888"); 857 case PIXEL_FORMAT_RGB_888: return String8("RGB_888"); 858 case PIXEL_FORMAT_RGB_565: return String8("RGB_565"); 859 case PIXEL_FORMAT_BGRA_8888: return String8("BGRA_8888"); 860 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 861 return String8("ImplDef"); 862 default: 863 String8 result; 864 result.appendFormat("? %08x", format); 865 return result; 866 } 867} 868*/ 869 870void HWComposer::dump(String8& result) const { 871 // TODO: In order to provide a dump equivalent to HWC1, we need to shadow 872 // all the state going into the layers. This is probably better done in 873 // Layer itself, but it's going to take a bit of work to get there. 874 result.append(mHwcDevice->dump().c_str()); 875} 876 877// --------------------------------------------------------------------------- 878 879HWComposer::DisplayData::DisplayData() 880 : hasClientComposition(false), 881 hasDeviceComposition(false), 882 hwcDisplay(), 883 lastPresentFence(Fence::NO_FENCE), 884 outbufHandle(nullptr), 885 outbufAcquireFence(Fence::NO_FENCE), 886 vsyncEnabled(HWC2::Vsync::Disable) { 887 ALOGV("Created new DisplayData"); 888} 889 890HWComposer::DisplayData::~DisplayData() { 891} 892 893void HWComposer::DisplayData::reset() { 894 ALOGV("DisplayData reset"); 895 *this = DisplayData(); 896} 897 898void HWComposerBufferCache::clear() 899{ 900 mBuffers.clear(); 901} 902 903void HWComposerBufferCache::getHwcBuffer(int slot, 904 const sp<GraphicBuffer>& buffer, 905 uint32_t* outSlot, sp<GraphicBuffer>* outBuffer) 906{ 907 if (slot == BufferQueue::INVALID_BUFFER_SLOT || slot < 0) { 908 // default to slot 0 909 slot = 0; 910 } 911 912 if (static_cast<size_t>(slot) >= mBuffers.size()) { 913 mBuffers.resize(slot + 1); 914 } 915 916 *outSlot = slot; 917 918 if (mBuffers[slot] == buffer) { 919 // already cached in HWC, skip sending the buffer 920 *outBuffer = nullptr; 921 } else { 922 *outBuffer = buffer; 923 924 // update cache 925 mBuffers[slot] = buffer; 926 } 927} 928 929// --------------------------------------------------------------------------- 930}; // namespace android 931