drmdisplaycompositor.cpp

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