drmdisplaycompositor.cpp revision 0c7da1e236c3a31a5bc171aac4d5f2a1033f10e1
1/* 2 * Copyright (C) 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 ATRACE_TAG ATRACE_TAG_GRAPHICS 18#define LOG_TAG "hwc-drm-display-compositor" 19 20#include "drmdisplaycompositor.h" 21 22#include <pthread.h> 23#include <sched.h> 24#include <stdlib.h> 25#include <time.h> 26#include <sstream> 27#include <vector> 28 29#include <cutils/log.h> 30#include <drm/drm_mode.h> 31#include <sync/sync.h> 32#include <utils/Trace.h> 33 34#include "autolock.h" 35#include "drmcrtc.h" 36#include "drmplane.h" 37#include "drmresources.h" 38#include "glworker.h" 39 40#define DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH 2 41 42namespace android { 43 44void SquashState::Init(DrmHwcLayer *layers, size_t num_layers) { 45 generation_number_++; 46 valid_history_ = 0; 47 regions_.clear(); 48 last_handles_.clear(); 49 50 std::vector<DrmHwcRect<int>> in_rects; 51 for (size_t i = 0; i < num_layers; i++) { 52 DrmHwcLayer *layer = &layers[i]; 53 in_rects.emplace_back(layer->display_frame); 54 last_handles_.push_back(layer->sf_handle); 55 } 56 57 std::vector<separate_rects::RectSet<uint64_t, int>> out_regions; 58 separate_rects::separate_rects_64(in_rects, &out_regions); 59 60 for (const separate_rects::RectSet<uint64_t, int> &out_region : out_regions) { 61 regions_.emplace_back(); 62 Region ®ion = regions_.back(); 63 region.rect = out_region.rect; 64 region.layer_refs = out_region.id_set.getBits(); 65 } 66} 67 68void SquashState::GenerateHistory(DrmHwcLayer *layers, size_t num_layers, 69 std::vector<bool> &changed_regions) const { 70 changed_regions.resize(regions_.size()); 71 if (num_layers != last_handles_.size()) { 72 ALOGE("SquashState::GenerateHistory expected %zu layers but got %zu layers", 73 last_handles_.size(), num_layers); 74 return; 75 } 76 std::bitset<kMaxLayers> changed_layers; 77 for (size_t i = 0; i < last_handles_.size(); i++) { 78 DrmHwcLayer *layer = &layers[i]; 79 // Protected layers can't be squashed so we treat them as constantly 80 // changing. 81 if (layer->protected_usage() || last_handles_[i] != layer->sf_handle) 82 changed_layers.set(i); 83 } 84 85 for (size_t i = 0; i < regions_.size(); i++) { 86 changed_regions[i] = (regions_[i].layer_refs & changed_layers).any(); 87 } 88} 89 90void SquashState::StableRegionsWithMarginalHistory( 91 const std::vector<bool> &changed_regions, 92 std::vector<bool> &stable_regions) const { 93 stable_regions.resize(regions_.size()); 94 for (size_t i = 0; i < regions_.size(); i++) { 95 stable_regions[i] = !changed_regions[i] && is_stable(i); 96 } 97} 98 99void SquashState::RecordHistory(DrmHwcLayer *layers, size_t num_layers, 100 const std::vector<bool> &changed_regions) { 101 if (num_layers != last_handles_.size()) { 102 ALOGE("SquashState::RecordHistory expected %zu layers but got %zu layers", 103 last_handles_.size(), num_layers); 104 return; 105 } 106 if (changed_regions.size() != regions_.size()) { 107 ALOGE("SquashState::RecordHistory expected %zu regions but got %zu regions", 108 regions_.size(), changed_regions.size()); 109 return; 110 } 111 112 for (size_t i = 0; i < last_handles_.size(); i++) { 113 DrmHwcLayer *layer = &layers[i]; 114 last_handles_[i] = layer->sf_handle; 115 } 116 117 for (size_t i = 0; i < regions_.size(); i++) { 118 regions_[i].change_history <<= 1; 119 regions_[i].change_history.set(/* LSB */ 0, changed_regions[i]); 120 } 121 122 valid_history_++; 123} 124 125bool SquashState::RecordAndCompareSquashed( 126 const std::vector<bool> &squashed_regions) { 127 if (squashed_regions.size() != regions_.size()) { 128 ALOGE( 129 "SquashState::RecordAndCompareSquashed expected %zu regions but got " 130 "%zu regions", 131 regions_.size(), squashed_regions.size()); 132 return false; 133 } 134 bool changed = false; 135 for (size_t i = 0; i < regions_.size(); i++) { 136 if (regions_[i].squashed != squashed_regions[i]) { 137 regions_[i].squashed = squashed_regions[i]; 138 changed = true; 139 } 140 } 141 return changed; 142} 143 144void SquashState::Dump(std::ostringstream *out) const { 145 *out << "----SquashState generation=" << generation_number_ 146 << " history=" << valid_history_ << "\n" 147 << " Regions: count=" << regions_.size() << "\n"; 148 for (size_t i = 0; i < regions_.size(); i++) { 149 const Region ®ion = regions_[i]; 150 *out << " [" << i << "]" 151 << " history=" << region.change_history << " rect"; 152 region.rect.Dump(out); 153 *out << " layers=("; 154 bool first = true; 155 for (size_t layer_index = 0; layer_index < kMaxLayers; layer_index++) { 156 if ((region.layer_refs & 157 std::bitset<kMaxLayers>((size_t)1 << layer_index)) 158 .any()) { 159 if (!first) 160 *out << " "; 161 first = false; 162 *out << layer_index; 163 } 164 } 165 *out << ")"; 166 if (region.squashed) 167 *out << " squashed"; 168 *out << "\n"; 169 } 170} 171 172static bool UsesSquash(const std::vector<DrmCompositionPlane> &comp_planes) { 173 return std::any_of(comp_planes.begin(), comp_planes.end(), 174 [](const DrmCompositionPlane &plane) { 175 return plane.source_layer == 176 DrmCompositionPlane::kSourceSquash; 177 }); 178} 179 180DrmDisplayCompositor::FrameWorker::FrameWorker(DrmDisplayCompositor *compositor) 181 : Worker("frame-worker", HAL_PRIORITY_URGENT_DISPLAY), 182 compositor_(compositor) { 183} 184 185DrmDisplayCompositor::FrameWorker::~FrameWorker() { 186} 187 188int DrmDisplayCompositor::FrameWorker::Init() { 189 return InitWorker(); 190} 191 192void DrmDisplayCompositor::FrameWorker::QueueFrame( 193 std::unique_ptr<DrmDisplayComposition> composition, int status) { 194 Lock(); 195 FrameState frame; 196 frame.composition = std::move(composition); 197 frame.status = status; 198 frame_queue_.push(std::move(frame)); 199 SignalLocked(); 200 Unlock(); 201} 202 203void DrmDisplayCompositor::FrameWorker::Routine() { 204 int ret = Lock(); 205 if (ret) { 206 ALOGE("Failed to lock worker, %d", ret); 207 return; 208 } 209 210 int wait_ret = 0; 211 if (frame_queue_.empty()) { 212 wait_ret = WaitForSignalOrExitLocked(); 213 } 214 215 FrameState frame; 216 if (!frame_queue_.empty()) { 217 frame = std::move(frame_queue_.front()); 218 frame_queue_.pop(); 219 } 220 221 ret = Unlock(); 222 if (ret) { 223 ALOGE("Failed to unlock worker, %d", ret); 224 return; 225 } 226 227 if (wait_ret == -EINTR) { 228 return; 229 } else if (wait_ret) { 230 ALOGE("Failed to wait for signal, %d", wait_ret); 231 return; 232 } 233 234 compositor_->ApplyFrame(std::move(frame.composition), frame.status); 235} 236 237DrmDisplayCompositor::DrmDisplayCompositor() 238 : drm_(NULL), 239 display_(-1), 240 worker_(this), 241 frame_worker_(this), 242 initialized_(false), 243 active_(false), 244 framebuffer_index_(0), 245 squash_framebuffer_index_(0), 246 dump_frames_composited_(0), 247 dump_last_timestamp_ns_(0) { 248 struct timespec ts; 249 if (clock_gettime(CLOCK_MONOTONIC, &ts)) 250 return; 251 dump_last_timestamp_ns_ = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec; 252} 253 254DrmDisplayCompositor::~DrmDisplayCompositor() { 255 if (!initialized_) 256 return; 257 258 worker_.Exit(); 259 frame_worker_.Exit(); 260 261 int ret = pthread_mutex_lock(&lock_); 262 if (ret) 263 ALOGE("Failed to acquire compositor lock %d", ret); 264 265 if (mode_.blob_id) 266 drm_->DestroyPropertyBlob(mode_.blob_id); 267 if (mode_.old_blob_id) 268 drm_->DestroyPropertyBlob(mode_.old_blob_id); 269 270 while (!composite_queue_.empty()) { 271 composite_queue_.front().reset(); 272 composite_queue_.pop(); 273 } 274 active_composition_.reset(); 275 276 ret = pthread_mutex_unlock(&lock_); 277 if (ret) 278 ALOGE("Failed to acquire compositor lock %d", ret); 279 280 pthread_mutex_destroy(&lock_); 281} 282 283int DrmDisplayCompositor::Init(DrmResources *drm, int display) { 284 drm_ = drm; 285 display_ = display; 286 287 int ret = pthread_mutex_init(&lock_, NULL); 288 if (ret) { 289 ALOGE("Failed to initialize drm compositor lock %d\n", ret); 290 return ret; 291 } 292 ret = worker_.Init(); 293 if (ret) { 294 pthread_mutex_destroy(&lock_); 295 ALOGE("Failed to initialize compositor worker %d\n", ret); 296 return ret; 297 } 298 ret = frame_worker_.Init(); 299 if (ret) { 300 pthread_mutex_destroy(&lock_); 301 ALOGE("Failed to initialize frame worker %d\n", ret); 302 return ret; 303 } 304 305 initialized_ = true; 306 return 0; 307} 308 309std::unique_ptr<DrmDisplayComposition> DrmDisplayCompositor::CreateComposition() 310 const { 311 return std::unique_ptr<DrmDisplayComposition>(new DrmDisplayComposition()); 312} 313 314int DrmDisplayCompositor::QueueComposition( 315 std::unique_ptr<DrmDisplayComposition> composition) { 316 switch (composition->type()) { 317 case DRM_COMPOSITION_TYPE_FRAME: 318 if (!active_) 319 return -ENODEV; 320 break; 321 case DRM_COMPOSITION_TYPE_DPMS: 322 /* 323 * Update the state as soon as we get it so we can start/stop queuing 324 * frames asap. 325 */ 326 active_ = (composition->dpms_mode() == DRM_MODE_DPMS_ON); 327 break; 328 case DRM_COMPOSITION_TYPE_MODESET: 329 break; 330 case DRM_COMPOSITION_TYPE_EMPTY: 331 return 0; 332 default: 333 ALOGE("Unknown composition type %d/%d", composition->type(), display_); 334 return -ENOENT; 335 } 336 337 int ret = pthread_mutex_lock(&lock_); 338 if (ret) { 339 ALOGE("Failed to acquire compositor lock %d", ret); 340 return ret; 341 } 342 343 // Block the queue if it gets too large. Otherwise, SurfaceFlinger will start 344 // to eat our buffer handles when we get about 1 second behind. 345 while (composite_queue_.size() >= DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH) { 346 pthread_mutex_unlock(&lock_); 347 sched_yield(); 348 pthread_mutex_lock(&lock_); 349 } 350 351 composite_queue_.push(std::move(composition)); 352 353 ret = pthread_mutex_unlock(&lock_); 354 if (ret) { 355 ALOGE("Failed to release compositor lock %d", ret); 356 return ret; 357 } 358 359 worker_.Signal(); 360 return 0; 361} 362 363std::tuple<uint32_t, uint32_t, int> 364DrmDisplayCompositor::GetActiveModeResolution() { 365 DrmConnector *connector = drm_->GetConnectorForDisplay(display_); 366 if (connector == NULL) { 367 ALOGE("Failed to determine display mode: no connector for display %d", 368 display_); 369 return std::make_tuple(0, 0, -ENODEV); 370 } 371 372 const DrmMode &mode = connector->active_mode(); 373 return std::make_tuple(mode.h_display(), mode.v_display(), 0); 374} 375 376int DrmDisplayCompositor::PrepareFramebuffer( 377 DrmFramebuffer &fb, DrmDisplayComposition *display_comp) { 378 int ret = fb.WaitReleased(-1); 379 if (ret) { 380 ALOGE("Failed to wait for framebuffer release %d", ret); 381 return ret; 382 } 383 uint32_t width, height; 384 std::tie(width, height, ret) = GetActiveModeResolution(); 385 if (ret) { 386 ALOGE( 387 "Failed to allocate framebuffer because the display resolution could " 388 "not be determined %d", 389 ret); 390 return ret; 391 } 392 393 fb.set_release_fence_fd(-1); 394 if (!fb.Allocate(width, height)) { 395 ALOGE("Failed to allocate framebuffer with size %dx%d", width, height); 396 return -ENOMEM; 397 } 398 399 display_comp->layers().emplace_back(); 400 DrmHwcLayer &pre_comp_layer = display_comp->layers().back(); 401 pre_comp_layer.sf_handle = fb.buffer()->handle; 402 pre_comp_layer.blending = DrmHwcBlending::kPreMult; 403 pre_comp_layer.source_crop = DrmHwcRect<float>(0, 0, width, height); 404 pre_comp_layer.display_frame = DrmHwcRect<int>(0, 0, width, height); 405 ret = pre_comp_layer.buffer.ImportBuffer(fb.buffer()->handle, 406 display_comp->importer()); 407 if (ret) { 408 ALOGE("Failed to import framebuffer for display %d", ret); 409 return ret; 410 } 411 412 return ret; 413} 414 415int DrmDisplayCompositor::ApplySquash(DrmDisplayComposition *display_comp) { 416 int ret = 0; 417 418 DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_]; 419 ret = PrepareFramebuffer(fb, display_comp); 420 if (ret) { 421 ALOGE("Failed to prepare framebuffer for squash %d", ret); 422 return ret; 423 } 424 425 std::vector<DrmCompositionRegion> ®ions = display_comp->squash_regions(); 426 ret = pre_compositor_->Composite(display_comp->layers().data(), 427 regions.data(), regions.size(), fb.buffer()); 428 pre_compositor_->Finish(); 429 430 if (ret) { 431 ALOGE("Failed to squash layers"); 432 return ret; 433 } 434 435 ret = display_comp->CreateNextTimelineFence(); 436 if (ret <= 0) { 437 ALOGE("Failed to create squash framebuffer release fence %d", ret); 438 return ret; 439 } 440 441 fb.set_release_fence_fd(ret); 442 display_comp->SignalSquashDone(); 443 444 return 0; 445} 446 447int DrmDisplayCompositor::ApplyPreComposite( 448 DrmDisplayComposition *display_comp) { 449 int ret = 0; 450 451 DrmFramebuffer &fb = framebuffers_[framebuffer_index_]; 452 ret = PrepareFramebuffer(fb, display_comp); 453 if (ret) { 454 ALOGE("Failed to prepare framebuffer for pre-composite %d", ret); 455 return ret; 456 } 457 458 std::vector<DrmCompositionRegion> ®ions = display_comp->pre_comp_regions(); 459 ret = pre_compositor_->Composite(display_comp->layers().data(), 460 regions.data(), regions.size(), fb.buffer()); 461 pre_compositor_->Finish(); 462 463 if (ret) { 464 ALOGE("Failed to pre-composite layers"); 465 return ret; 466 } 467 468 ret = display_comp->CreateNextTimelineFence(); 469 if (ret <= 0) { 470 ALOGE("Failed to create pre-composite framebuffer release fence %d", ret); 471 return ret; 472 } 473 474 fb.set_release_fence_fd(ret); 475 display_comp->SignalPreCompDone(); 476 477 return 0; 478} 479 480int DrmDisplayCompositor::DisablePlanes(DrmDisplayComposition *display_comp) { 481 drmModePropertySetPtr pset = drmModePropertySetAlloc(); 482 if (!pset) { 483 ALOGE("Failed to allocate property set"); 484 return -ENOMEM; 485 } 486 487 int ret; 488 std::vector<DrmCompositionPlane> &comp_planes = 489 display_comp->composition_planes(); 490 for (DrmCompositionPlane &comp_plane : comp_planes) { 491 DrmPlane *plane = comp_plane.plane; 492 ret = 493 drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(), 494 0) || 495 drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(), 0); 496 if (ret) { 497 ALOGE("Failed to add plane %d disable to pset", plane->id()); 498 drmModePropertySetFree(pset); 499 return ret; 500 } 501 } 502 503 ret = drmModePropertySetCommit(drm_->fd(), 0, drm_, pset); 504 if (ret) { 505 ALOGE("Failed to commit pset ret=%d\n", ret); 506 drmModePropertySetFree(pset); 507 return ret; 508 } 509 510 drmModePropertySetFree(pset); 511 return 0; 512} 513 514int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) { 515 int ret = 0; 516 517 std::vector<DrmHwcLayer> &layers = display_comp->layers(); 518 std::vector<DrmCompositionPlane> &comp_planes = 519 display_comp->composition_planes(); 520 std::vector<DrmCompositionRegion> &squash_regions = 521 display_comp->squash_regions(); 522 std::vector<DrmCompositionRegion> &pre_comp_regions = 523 display_comp->pre_comp_regions(); 524 525 int squash_layer_index = -1; 526 if (squash_regions.size() > 0) { 527 squash_framebuffer_index_ = (squash_framebuffer_index_ + 1) % 2; 528 ret = ApplySquash(display_comp); 529 if (ret) 530 return ret; 531 532 squash_layer_index = layers.size() - 1; 533 } else { 534 if (UsesSquash(comp_planes)) { 535 DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_]; 536 layers.emplace_back(); 537 squash_layer_index = layers.size() - 1; 538 DrmHwcLayer &squash_layer = layers.back(); 539 ret = squash_layer.buffer.ImportBuffer(fb.buffer()->handle, 540 display_comp->importer()); 541 if (ret) { 542 ALOGE("Failed to import old squashed framebuffer %d", ret); 543 return ret; 544 } 545 squash_layer.sf_handle = fb.buffer()->handle; 546 squash_layer.blending = DrmHwcBlending::kPreMult; 547 squash_layer.source_crop = DrmHwcRect<float>( 548 0, 0, squash_layer.buffer->width, squash_layer.buffer->height); 549 squash_layer.display_frame = DrmHwcRect<int>( 550 0, 0, squash_layer.buffer->width, squash_layer.buffer->height); 551 ret = display_comp->CreateNextTimelineFence(); 552 553 if (ret <= 0) { 554 ALOGE("Failed to create squash framebuffer release fence %d", ret); 555 return ret; 556 } 557 558 fb.set_release_fence_fd(ret); 559 ret = 0; 560 } 561 } 562 563 bool do_pre_comp = pre_comp_regions.size() > 0; 564 int pre_comp_layer_index = -1; 565 if (do_pre_comp) { 566 ret = ApplyPreComposite(display_comp); 567 if (ret) 568 return ret; 569 570 pre_comp_layer_index = layers.size() - 1; 571 framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS; 572 } 573 574 for (DrmCompositionPlane &comp_plane : comp_planes) { 575 switch (comp_plane.source_layer) { 576 case DrmCompositionPlane::kSourceSquash: 577 comp_plane.source_layer = squash_layer_index; 578 break; 579 case DrmCompositionPlane::kSourcePreComp: 580 if (!do_pre_comp) { 581 ALOGE( 582 "Can not use pre composite framebuffer with no pre composite " 583 "regions"); 584 return -EINVAL; 585 } 586 comp_plane.source_layer = pre_comp_layer_index; 587 break; 588 default: 589 break; 590 } 591 } 592 593 return ret; 594} 595 596int DrmDisplayCompositor::CommitFrame(DrmDisplayComposition *display_comp, 597 bool test_only) { 598 ATRACE_CALL(); 599 600 int ret = 0; 601 602 std::vector<DrmHwcLayer> &layers = display_comp->layers(); 603 std::vector<DrmCompositionPlane> &comp_planes = 604 display_comp->composition_planes(); 605 std::vector<DrmCompositionRegion> &pre_comp_regions = 606 display_comp->pre_comp_regions(); 607 608 DrmFramebuffer *pre_comp_fb; 609 610 DrmConnector *connector = drm_->GetConnectorForDisplay(display_); 611 if (!connector) { 612 ALOGE("Could not locate connector for display %d", display_); 613 return -ENODEV; 614 } 615 DrmCrtc *crtc = drm_->GetCrtcForDisplay(display_); 616 if (!crtc) { 617 ALOGE("Could not locate crtc for display %d", display_); 618 return -ENODEV; 619 } 620 621 drmModePropertySetPtr pset = drmModePropertySetAlloc(); 622 if (!pset) { 623 ALOGE("Failed to allocate property set"); 624 return -ENOMEM; 625 } 626 627 if (mode_.needs_modeset) { 628 ret = drmModePropertySetAdd(pset, crtc->id(), crtc->mode_property().id(), 629 mode_.blob_id) || 630 drmModePropertySetAdd(pset, connector->id(), 631 connector->crtc_id_property().id(), crtc->id()); 632 if (ret) { 633 ALOGE("Failed to add blob %d to pset", mode_.blob_id); 634 drmModePropertySetFree(pset); 635 return ret; 636 } 637 } 638 639 for (DrmCompositionPlane &comp_plane : comp_planes) { 640 DrmPlane *plane = comp_plane.plane; 641 DrmCrtc *crtc = comp_plane.crtc; 642 643 int fb_id = -1; 644 DrmHwcRect<int> display_frame; 645 DrmHwcRect<float> source_crop; 646 uint64_t rotation = 0; 647 uint64_t alpha = 0xFF; 648 switch (comp_plane.source_layer) { 649 case DrmCompositionPlane::kSourceNone: 650 break; 651 case DrmCompositionPlane::kSourceSquash: 652 ALOGE("Actual source layer index expected for squash layer"); 653 break; 654 case DrmCompositionPlane::kSourcePreComp: 655 ALOGE("Actual source layer index expected for pre-comp layer"); 656 break; 657 default: { 658 if (comp_plane.source_layer >= layers.size()) { 659 ALOGE("Source layer index %zu out of bounds %zu", 660 comp_plane.source_layer, layers.size()); 661 break; 662 } 663 DrmHwcLayer &layer = layers[comp_plane.source_layer]; 664 if (!test_only && layer.acquire_fence.get() >= 0) { 665 int acquire_fence = layer.acquire_fence.get(); 666 for (int i = 0; i < kAcquireWaitTries; ++i) { 667 ret = sync_wait(acquire_fence, kAcquireWaitTimeoutMs); 668 if (ret) 669 ALOGW("Acquire fence %d wait %d failed (%d). Total time %d", 670 acquire_fence, i, ret, (i + 1) * kAcquireWaitTimeoutMs); 671 } 672 if (ret) { 673 ALOGE("Failed to wait for acquire %d/%d", acquire_fence, ret); 674 break; 675 } 676 layer.acquire_fence.Close(); 677 } 678 if (!layer.buffer) { 679 ALOGE("Expected a valid framebuffer for pset"); 680 break; 681 } 682 fb_id = layer.buffer->fb_id; 683 display_frame = layer.display_frame; 684 source_crop = layer.source_crop; 685 if (layer.blending == DrmHwcBlending::kPreMult) 686 alpha = layer.alpha; 687 688 rotation = 0; 689 if (layer.transform & DrmHwcTransform::kFlipH) 690 rotation |= 1 << DRM_REFLECT_X; 691 if (layer.transform & DrmHwcTransform::kFlipV) 692 rotation |= 1 << DRM_REFLECT_Y; 693 if (layer.transform & DrmHwcTransform::kRotate90) 694 rotation |= 1 << DRM_ROTATE_90; 695 else if (layer.transform & DrmHwcTransform::kRotate180) 696 rotation |= 1 << DRM_ROTATE_180; 697 else if (layer.transform & DrmHwcTransform::kRotate270) 698 rotation |= 1 << DRM_ROTATE_270; 699 } 700 } 701 702 // Disable the plane if there's no framebuffer 703 if (fb_id < 0) { 704 ret = drmModePropertySetAdd(pset, plane->id(), 705 plane->crtc_property().id(), 0) || 706 drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(), 707 0); 708 if (ret) { 709 ALOGE("Failed to add plane %d disable to pset", plane->id()); 710 break; 711 } 712 continue; 713 } 714 715 // TODO: Once we have atomic test, this should fall back to GL 716 if (rotation && plane->rotation_property().id() == 0) { 717 ALOGE("Rotation is not supported on plane %d", plane->id()); 718 ret = -EINVAL; 719 break; 720 } 721 722 // TODO: Once we have atomic test, this should fall back to GL 723 if (alpha != 0xFF && plane->alpha_property().id() == 0) { 724 ALOGE("Alpha is not supported on plane %d", plane->id()); 725 ret = -EINVAL; 726 break; 727 } 728 729 ret = 730 drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(), 731 crtc->id()) || 732 drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(), 733 fb_id) || 734 drmModePropertySetAdd(pset, plane->id(), plane->crtc_x_property().id(), 735 display_frame.left) || 736 drmModePropertySetAdd(pset, plane->id(), plane->crtc_y_property().id(), 737 display_frame.top) || 738 drmModePropertySetAdd(pset, plane->id(), plane->crtc_w_property().id(), 739 display_frame.right - display_frame.left) || 740 drmModePropertySetAdd(pset, plane->id(), plane->crtc_h_property().id(), 741 display_frame.bottom - display_frame.top) || 742 drmModePropertySetAdd(pset, plane->id(), plane->src_x_property().id(), 743 (int)(source_crop.left) << 16) || 744 drmModePropertySetAdd(pset, plane->id(), plane->src_y_property().id(), 745 (int)(source_crop.top) << 16) || 746 drmModePropertySetAdd(pset, plane->id(), plane->src_w_property().id(), 747 (int)(source_crop.right - source_crop.left) 748 << 16) || 749 drmModePropertySetAdd(pset, plane->id(), plane->src_h_property().id(), 750 (int)(source_crop.bottom - source_crop.top) 751 << 16); 752 if (ret) { 753 ALOGE("Failed to add plane %d to set", plane->id()); 754 break; 755 } 756 757 if (plane->rotation_property().id()) { 758 ret = drmModePropertySetAdd(pset, plane->id(), 759 plane->rotation_property().id(), rotation); 760 if (ret) { 761 ALOGE("Failed to add rotation property %d to plane %d", 762 plane->rotation_property().id(), plane->id()); 763 break; 764 } 765 } 766 767 if (plane->alpha_property().id()) { 768 ret = drmModePropertySetAdd(pset, plane->id(), 769 plane->alpha_property().id(), alpha); 770 if (ret) { 771 ALOGE("Failed to add alpha property %d to plane %d", 772 plane->alpha_property().id(), plane->id()); 773 break; 774 } 775 } 776 } 777 778out: 779 if (!ret) { 780 uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET; 781 if (test_only) 782 flags |= DRM_MODE_ATOMIC_TEST_ONLY; 783 784 ret = drmModePropertySetCommit(drm_->fd(), flags, drm_, pset); 785 if (ret) { 786 if (test_only) 787 ALOGI("Commit test pset failed ret=%d\n", ret); 788 else 789 ALOGE("Failed to commit pset ret=%d\n", ret); 790 drmModePropertySetFree(pset); 791 return ret; 792 } 793 } 794 if (pset) 795 drmModePropertySetFree(pset); 796 797 if (!test_only && mode_.needs_modeset) { 798 ret = drm_->DestroyPropertyBlob(mode_.old_blob_id); 799 if (ret) { 800 ALOGE("Failed to destroy old mode property blob %lld/%d", 801 mode_.old_blob_id, ret); 802 return ret; 803 } 804 805 /* TODO: Add dpms to the pset when the kernel supports it */ 806 ret = ApplyDpms(display_comp); 807 if (ret) { 808 ALOGE("Failed to apply DPMS after modeset %d\n", ret); 809 return ret; 810 } 811 812 connector->set_active_mode(mode_.mode); 813 mode_.old_blob_id = mode_.blob_id; 814 mode_.blob_id = 0; 815 mode_.needs_modeset = false; 816 } 817 818 return ret; 819} 820 821int DrmDisplayCompositor::ApplyDpms(DrmDisplayComposition *display_comp) { 822 DrmConnector *conn = drm_->GetConnectorForDisplay(display_); 823 if (!conn) { 824 ALOGE("Failed to get DrmConnector for display %d", display_); 825 return -ENODEV; 826 } 827 828 const DrmProperty &prop = conn->dpms_property(); 829 int ret = drmModeConnectorSetProperty(drm_->fd(), conn->id(), prop.id(), 830 display_comp->dpms_mode()); 831 if (ret) { 832 ALOGE("Failed to set DPMS property for connector %d", conn->id()); 833 return ret; 834 } 835 return 0; 836} 837 838std::tuple<int, uint32_t> DrmDisplayCompositor::CreateModeBlob( 839 const DrmMode &mode) { 840 struct drm_mode_modeinfo drm_mode; 841 memset(&drm_mode, 0, sizeof(drm_mode)); 842 mode.ToDrmModeModeInfo(&drm_mode); 843 844 uint32_t id = 0; 845 int ret = drm_->CreatePropertyBlob(&drm_mode, 846 sizeof(struct drm_mode_modeinfo), &id); 847 if (ret) { 848 ALOGE("Failed to create mode property blob %d", ret); 849 return std::make_tuple(ret, 0); 850 } 851 ALOGE("Create blob_id %ld\n", id); 852 return std::make_tuple(ret, id); 853} 854 855void DrmDisplayCompositor::ApplyFrame( 856 std::unique_ptr<DrmDisplayComposition> composition, int status) { 857 int ret = status; 858 859 if (!ret) 860 ret = CommitFrame(composition.get(), false); 861 862 if (ret) { 863 ALOGE("Composite failed for display %d", display_); 864 865 // Disable the hw used by the last active composition. This allows us to 866 // signal the release fences from that composition to avoid hanging. 867 if (DisablePlanes(active_composition_.get())) 868 return; 869 } 870 ++dump_frames_composited_; 871 872 if (active_composition_) 873 active_composition_->SignalCompositionDone(); 874 875 ret = pthread_mutex_lock(&lock_); 876 if (ret) 877 ALOGE("Failed to acquire lock for active_composition swap"); 878 879 active_composition_.swap(composition); 880 881 if (!ret) 882 ret = pthread_mutex_unlock(&lock_); 883 if (ret) 884 ALOGE("Failed to release lock for active_composition swap"); 885} 886 887int DrmDisplayCompositor::Composite() { 888 ATRACE_CALL(); 889 890 if (!pre_compositor_) { 891 pre_compositor_.reset(new GLWorkerCompositor()); 892 int ret = pre_compositor_->Init(); 893 if (ret) { 894 ALOGE("Failed to initialize OpenGL compositor %d", ret); 895 return ret; 896 } 897 } 898 899 int ret = pthread_mutex_lock(&lock_); 900 if (ret) { 901 ALOGE("Failed to acquire compositor lock %d", ret); 902 return ret; 903 } 904 if (composite_queue_.empty()) { 905 ret = pthread_mutex_unlock(&lock_); 906 if (ret) 907 ALOGE("Failed to release compositor lock %d", ret); 908 return ret; 909 } 910 911 std::unique_ptr<DrmDisplayComposition> composition( 912 std::move(composite_queue_.front())); 913 914 composite_queue_.pop(); 915 916 ret = pthread_mutex_unlock(&lock_); 917 if (ret) { 918 ALOGE("Failed to release compositor lock %d", ret); 919 return ret; 920 } 921 922 switch (composition->type()) { 923 case DRM_COMPOSITION_TYPE_FRAME: 924 ret = PrepareFrame(composition.get()); 925 if (ret) { 926 ALOGE("Failed to prepare frame for display %d", display_); 927 return ret; 928 } 929 // Send the composition to the kernel to ensure we can commit it. This is 930 // just a test, it won't actually commit the frame. If the kernel rejects 931 // it, squash the frame into one layer and use the squashed composition 932 ret = CommitFrame(composition.get(), true); 933 if (ret) { 934 ALOGI("Commit test failed, squashing frame for display %d", display_); 935 std::unique_ptr<DrmDisplayComposition> squashed = CreateComposition(); 936 ret = SquashFrame(composition.get(), squashed.get()); 937 if (!ret) { 938 composition = std::move(squashed); 939 } else { 940 ALOGE("Failed to squash frame for display %d", display_); 941 return ret; 942 } 943 } 944 frame_worker_.QueueFrame(std::move(composition), ret); 945 break; 946 case DRM_COMPOSITION_TYPE_DPMS: 947 ret = ApplyDpms(composition.get()); 948 if (ret) 949 ALOGE("Failed to apply dpms for display %d", display_); 950 return ret; 951 case DRM_COMPOSITION_TYPE_MODESET: 952 mode_.mode = composition->display_mode(); 953 if (mode_.blob_id) 954 drm_->DestroyPropertyBlob(mode_.blob_id); 955 std::tie(ret, mode_.blob_id) = CreateModeBlob(mode_.mode); 956 if (ret) { 957 ALOGE("Failed to create mode blob for display %d", display_); 958 return ret; 959 } 960 mode_.needs_modeset = true; 961 return 0; 962 default: 963 ALOGE("Unknown composition type %d", composition->type()); 964 return -EINVAL; 965 } 966 967 return ret; 968} 969 970bool DrmDisplayCompositor::HaveQueuedComposites() const { 971 int ret = pthread_mutex_lock(&lock_); 972 if (ret) { 973 ALOGE("Failed to acquire compositor lock %d", ret); 974 return false; 975 } 976 977 bool empty_ret = !composite_queue_.empty(); 978 979 ret = pthread_mutex_unlock(&lock_); 980 if (ret) { 981 ALOGE("Failed to release compositor lock %d", ret); 982 return false; 983 } 984 985 return empty_ret; 986} 987 988int DrmDisplayCompositor::SquashAll() { 989 AutoLock lock(&lock_, "compositor"); 990 int ret = lock.Lock(); 991 if (ret) 992 return ret; 993 994 if (!active_composition_) 995 return 0; 996 997 std::unique_ptr<DrmDisplayComposition> comp = CreateComposition(); 998 ret = SquashFrame(active_composition_.get(), comp.get()); 999 1000 // ApplyFrame needs the lock 1001 lock.Unlock(); 1002 1003 if (!ret) 1004 ApplyFrame(std::move(comp), 0); 1005 1006 return ret; 1007} 1008 1009// Returns: 1010// - 0 if src is successfully squashed into dst 1011// - -EALREADY if the src is already squashed 1012// - Appropriate error if the squash fails 1013int DrmDisplayCompositor::SquashFrame(DrmDisplayComposition *src, 1014 DrmDisplayComposition *dst) { 1015 if (src->type() != DRM_COMPOSITION_TYPE_FRAME) 1016 return -ENOTSUP; 1017 1018 std::vector<DrmCompositionPlane> &src_planes = src->composition_planes(); 1019 std::vector<DrmHwcLayer> &src_layers = src->layers(); 1020 1021 // Make sure there is more than one layer to squash. 1022 size_t src_planes_with_layer = std::count_if( 1023 src_planes.begin(), src_planes.end(), [](DrmCompositionPlane &p) { 1024 return p.source_layer <= DrmCompositionPlane::kSourceLayerMax; 1025 }); 1026 if (src_planes_with_layer <= 1) 1027 return -EALREADY; 1028 1029 int pre_comp_layer_index; 1030 1031 int ret = dst->Init(drm_, src->crtc(), src->importer(), src->frame_no()); 1032 if (ret) { 1033 ALOGE("Failed to init squash all composition %d", ret); 1034 return ret; 1035 } 1036 1037 std::vector<DrmPlane *> primary_planes; 1038 std::vector<DrmPlane *> fake_overlay_planes; 1039 std::vector<DrmHwcLayer> dst_layers; 1040 for (DrmCompositionPlane &comp_plane : src_planes) { 1041 // Composition planes without DRM planes should never happen 1042 if (comp_plane.plane == NULL) { 1043 ALOGE("Skipping squash all because of NULL plane"); 1044 ret = -EINVAL; 1045 goto move_layers_back; 1046 } 1047 1048 if (comp_plane.source_layer == DrmCompositionPlane::kSourceNone) 1049 continue; 1050 1051 // Out of range layers should never happen. If they do, somebody probably 1052 // forgot to replace the symbolic names (kSourceSquash, kSourcePreComp) with 1053 // real ones. 1054 if (comp_plane.source_layer >= src_layers.size()) { 1055 ALOGE("Skipping squash all because of out of range source layer %zu", 1056 comp_plane.source_layer); 1057 ret = -EINVAL; 1058 goto move_layers_back; 1059 } 1060 1061 DrmHwcLayer &layer = src_layers[comp_plane.source_layer]; 1062 1063 // Squashing protected layers is impossible. 1064 if (layer.protected_usage()) { 1065 ret = -ENOTSUP; 1066 goto move_layers_back; 1067 } 1068 1069 // The OutputFds point to freed memory after hwc_set returns. They are 1070 // returned to the default to prevent DrmDisplayComposition::Plan from 1071 // filling the OutputFds. 1072 layer.release_fence = OutputFd(); 1073 dst_layers.emplace_back(std::move(layer)); 1074 1075 if (comp_plane.plane->type() == DRM_PLANE_TYPE_PRIMARY && 1076 primary_planes.size() == 0) 1077 primary_planes.push_back(comp_plane.plane); 1078 else 1079 dst->AddPlaneDisable(comp_plane.plane); 1080 } 1081 1082 ret = dst->SetLayers(dst_layers.data(), dst_layers.size(), false); 1083 if (ret) { 1084 ALOGE("Failed to set layers for squash all composition %d", ret); 1085 goto move_layers_back; 1086 } 1087 1088 ret = 1089 dst->Plan(NULL /* SquashState */, &primary_planes, &fake_overlay_planes); 1090 if (ret) { 1091 ALOGE("Failed to plan for squash all composition %d", ret); 1092 goto move_layers_back; 1093 } 1094 1095 ret = ApplyPreComposite(dst); 1096 if (ret) { 1097 ALOGE("Failed to pre-composite for squash all composition %d", ret); 1098 goto move_layers_back; 1099 } 1100 1101 pre_comp_layer_index = dst->layers().size() - 1; 1102 framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS; 1103 1104 for (DrmCompositionPlane &plane : dst->composition_planes()) 1105 if (plane.source_layer == DrmCompositionPlane::kSourcePreComp) 1106 plane.source_layer = pre_comp_layer_index; 1107 1108 return 0; 1109 1110// TODO(zachr): think of a better way to transfer ownership back to the active 1111// composition. 1112move_layers_back: 1113 for (size_t plane_index = 0; 1114 plane_index < src_planes.size() && plane_index < dst_layers.size(); 1115 plane_index++) { 1116 size_t source_layer_index = src_planes[plane_index].source_layer; 1117 src_layers[source_layer_index] = std::move(dst_layers[plane_index]); 1118 } 1119 1120 return ret; 1121} 1122 1123void DrmDisplayCompositor::Dump(std::ostringstream *out) const { 1124 int ret = pthread_mutex_lock(&lock_); 1125 if (ret) 1126 return; 1127 1128 uint64_t num_frames = dump_frames_composited_; 1129 dump_frames_composited_ = 0; 1130 1131 struct timespec ts; 1132 ret = clock_gettime(CLOCK_MONOTONIC, &ts); 1133 if (ret) { 1134 pthread_mutex_unlock(&lock_); 1135 return; 1136 } 1137 1138 uint64_t cur_ts = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec; 1139 uint64_t num_ms = (cur_ts - dump_last_timestamp_ns_) / (1000 * 1000); 1140 float fps = num_ms ? (num_frames * 1000.0f) / (num_ms) : 0.0f; 1141 1142 *out << "--DrmDisplayCompositor[" << display_ 1143 << "]: num_frames=" << num_frames << " num_ms=" << num_ms 1144 << " fps=" << fps << "\n"; 1145 1146 dump_last_timestamp_ns_ = cur_ts; 1147 1148 if (active_composition_) 1149 active_composition_->Dump(out); 1150 1151 squash_state_.Dump(out); 1152 1153 pthread_mutex_unlock(&lock_); 1154} 1155} 1156