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
  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 <log/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
  42 namespace android {
  43
  44 void 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 &region = regions_.back();
  63     region.rect = out_region.rect;
  64     region.layer_refs = out_region.id_set.getBits();
  65   }
  66 }
  67
  68 void 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
  90 void 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
  99 void 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
 125 bool 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
 144 void 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 &region = 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
 172 static 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.type() == DrmCompositionPlane::Type::kSquash;
 176   });
 177 }
 178
 179 DrmDisplayCompositor::FrameWorker::FrameWorker(DrmDisplayCompositor *compositor)
 180     : Worker("frame-worker", HAL_PRIORITY_URGENT_DISPLAY),
 181       compositor_(compositor) {
 182 }
 183
 184 DrmDisplayCompositor::FrameWorker::~FrameWorker() {
 185 }
 186
 187 int DrmDisplayCompositor::FrameWorker::Init() {
 188   return InitWorker();
 189 }
 190
 191 void DrmDisplayCompositor::FrameWorker::QueueFrame(
 192     std::unique_ptr<DrmDisplayComposition> composition, int status) {
 193   Lock();
 194   FrameState frame;
 195   frame.composition = std::move(composition);
 196   frame.status = status;
 197   frame_queue_.push(std::move(frame));
 198   Unlock();
 199   Signal();
 200 }
 201
 202 void DrmDisplayCompositor::FrameWorker::Routine() {
 203   int wait_ret = 0;
 204
 205   Lock();
 206   if (frame_queue_.empty()) {
 207     wait_ret = WaitForSignalOrExitLocked();
 208   }
 209
 210   FrameState frame;
 211   if (!frame_queue_.empty()) {
 212     frame = std::move(frame_queue_.front());
 213     frame_queue_.pop();
 214   }
 215   Unlock();
 216
 217   if (wait_ret == -EINTR) {
 218     return;
 219   } else if (wait_ret) {
 220     ALOGE("Failed to wait for signal, %d", wait_ret);
 221     return;
 222   }
 223   compositor_->ApplyFrame(std::move(frame.composition), frame.status);
 224 }
 225
 226 DrmDisplayCompositor::DrmDisplayCompositor()
 227     : drm_(NULL),
 228       display_(-1),
 229       worker_(this),
 230       frame_worker_(this),
 231       initialized_(false),
 232       active_(false),
 233       use_hw_overlays_(true),
 234       framebuffer_index_(0),
 235       squash_framebuffer_index_(0),
 236       dump_frames_composited_(0),
 237       dump_last_timestamp_ns_(0) {
 238   struct timespec ts;
 239   if (clock_gettime(CLOCK_MONOTONIC, &ts))
 240     return;
 241   dump_last_timestamp_ns_ = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
 242 }
 243
 244 DrmDisplayCompositor::~DrmDisplayCompositor() {
 245   if (!initialized_)
 246     return;
 247
 248   worker_.Exit();
 249   frame_worker_.Exit();
 250
 251   int ret = pthread_mutex_lock(&lock_);
 252   if (ret)
 253     ALOGE("Failed to acquire compositor lock %d", ret);
 254
 255   if (mode_.blob_id)
 256     drm_->DestroyPropertyBlob(mode_.blob_id);
 257   if (mode_.old_blob_id)
 258     drm_->DestroyPropertyBlob(mode_.old_blob_id);
 259
 260   while (!composite_queue_.empty()) {
 261     composite_queue_.front().reset();
 262     composite_queue_.pop();
 263   }
 264   active_composition_.reset();
 265
 266   ret = pthread_mutex_unlock(&lock_);
 267   if (ret)
 268     ALOGE("Failed to acquire compositor lock %d", ret);
 269
 270   pthread_mutex_destroy(&lock_);
 271 }
 272
 273 int DrmDisplayCompositor::Init(DrmResources *drm, int display) {
 274   drm_ = drm;
 275   display_ = display;
 276
 277   int ret = pthread_mutex_init(&lock_, NULL);
 278   if (ret) {
 279     ALOGE("Failed to initialize drm compositor lock %d\n", ret);
 280     return ret;
 281   }
 282   ret = worker_.Init();
 283   if (ret) {
 284     pthread_mutex_destroy(&lock_);
 285     ALOGE("Failed to initialize compositor worker %d\n", ret);
 286     return ret;
 287   }
 288   ret = frame_worker_.Init();
 289   if (ret) {
 290     pthread_mutex_destroy(&lock_);
 291     ALOGE("Failed to initialize frame worker %d\n", ret);
 292     return ret;
 293   }
 294
 295   pre_compositor_.reset(new GLWorkerCompositor());
 296   ret = pre_compositor_->Init();
 297   if (ret) {
 298     ALOGE("Failed to initialize OpenGL compositor %d", ret);
 299     pre_compositor_.reset();
 300   }
 301
 302   initialized_ = true;
 303   return 0;
 304 }
 305
 306 std::unique_ptr<DrmDisplayComposition> DrmDisplayCompositor::CreateComposition()
 307     const {
 308   return std::unique_ptr<DrmDisplayComposition>(new DrmDisplayComposition());
 309 }
 310
 311 int DrmDisplayCompositor::QueueComposition(
 312     std::unique_ptr<DrmDisplayComposition> composition) {
 313   switch (composition->type()) {
 314     case DRM_COMPOSITION_TYPE_FRAME:
 315       if (!active_)
 316         return -ENODEV;
 317       break;
 318     case DRM_COMPOSITION_TYPE_DPMS:
 319       /*
 320        * Update the state as soon as we get it so we can start/stop queuing
 321        * frames asap.
 322        */
 323       active_ = (composition->dpms_mode() == DRM_MODE_DPMS_ON);
 324       break;
 325     case DRM_COMPOSITION_TYPE_MODESET:
 326       break;
 327     case DRM_COMPOSITION_TYPE_EMPTY:
 328       return 0;
 329     default:
 330       ALOGE("Unknown composition type %d/%d", composition->type(), display_);
 331       return -ENOENT;
 332   }
 333
 334   int ret = pthread_mutex_lock(&lock_);
 335   if (ret) {
 336     ALOGE("Failed to acquire compositor lock %d", ret);
 337     return ret;
 338   }
 339
 340   // Block the queue if it gets too large. Otherwise, SurfaceFlinger will start
 341   // to eat our buffer handles when we get about 1 second behind.
 342   while (composite_queue_.size() >= DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH) {
 343     pthread_mutex_unlock(&lock_);
 344     sched_yield();
 345     pthread_mutex_lock(&lock_);
 346   }
 347
 348   composite_queue_.push(std::move(composition));
 349
 350   ret = pthread_mutex_unlock(&lock_);
 351   if (ret) {
 352     ALOGE("Failed to release compositor lock %d", ret);
 353     return ret;
 354   }
 355
 356   worker_.Signal();
 357   return 0;
 358 }
 359
 360 std::tuple<uint32_t, uint32_t, int>
 361 DrmDisplayCompositor::GetActiveModeResolution() {
 362   DrmConnector *connector = drm_->GetConnectorForDisplay(display_);
 363   if (connector == NULL) {
 364     ALOGE("Failed to determine display mode: no connector for display %d",
 365           display_);
 366     return std::make_tuple(0, 0, -ENODEV);
 367   }
 368
 369   const DrmMode &mode = connector->active_mode();
 370   return std::make_tuple(mode.h_display(), mode.v_display(), 0);
 371 }
 372
 373 int DrmDisplayCompositor::PrepareFramebuffer(
 374     DrmFramebuffer &fb, DrmDisplayComposition *display_comp) {
 375   int ret = fb.WaitReleased(-1);
 376   if (ret) {
 377     ALOGE("Failed to wait for framebuffer release %d", ret);
 378     return ret;
 379   }
 380   uint32_t width, height;
 381   std::tie(width, height, ret) = GetActiveModeResolution();
 382   if (ret) {
 383     ALOGE(
 384         "Failed to allocate framebuffer because the display resolution could "
 385         "not be determined %d",
 386         ret);
 387     return ret;
 388   }
 389
 390   fb.set_release_fence_fd(-1);
 391   if (!fb.Allocate(width, height)) {
 392     ALOGE("Failed to allocate framebuffer with size %dx%d", width, height);
 393     return -ENOMEM;
 394   }
 395
 396   display_comp->layers().emplace_back();
 397   DrmHwcLayer &pre_comp_layer = display_comp->layers().back();
 398   pre_comp_layer.sf_handle = fb.buffer()->handle;
 399   pre_comp_layer.blending = DrmHwcBlending::kPreMult;
 400   pre_comp_layer.source_crop = DrmHwcRect<float>(0, 0, width, height);
 401   pre_comp_layer.display_frame = DrmHwcRect<int>(0, 0, width, height);
 402   ret = pre_comp_layer.buffer.ImportBuffer(fb.buffer()->handle,
 403                                            display_comp->importer());
 404   if (ret) {
 405     ALOGE("Failed to import framebuffer for display %d", ret);
 406     return ret;
 407   }
 408
 409   return ret;
 410 }
 411
 412 int DrmDisplayCompositor::ApplySquash(DrmDisplayComposition *display_comp) {
 413   int ret = 0;
 414
 415   DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_];
 416   ret = PrepareFramebuffer(fb, display_comp);
 417   if (ret) {
 418     ALOGE("Failed to prepare framebuffer for squash %d", ret);
 419     return ret;
 420   }
 421
 422   std::vector<DrmCompositionRegion> &regions = display_comp->squash_regions();
 423   if (pre_compositor_) {
 424     ret = pre_compositor_->Composite(display_comp->layers().data(),
 425                                    regions.data(), regions.size(), fb.buffer(),
 426                                    display_comp->importer());
 427     pre_compositor_->Finish();
 428
 429     if (ret) {
 430       ALOGE("Failed to squash layers");
 431       return ret;
 432     }
 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
 447 int 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> &regions = display_comp->pre_comp_regions();
 459   if (pre_compositor_) {
 460     ret = pre_compositor_->Composite(display_comp->layers().data(),
 461                                    regions.data(), regions.size(), fb.buffer(),
 462                                    display_comp->importer());
 463     pre_compositor_->Finish();
 464
 465     if (ret) {
 466       ALOGE("Failed to pre-composite layers");
 467       return ret;
 468     }
 469   }
 470
 471   ret = display_comp->CreateNextTimelineFence();
 472   if (ret <= 0) {
 473     ALOGE("Failed to create pre-composite framebuffer release fence %d", ret);
 474     return ret;
 475   }
 476
 477   fb.set_release_fence_fd(ret);
 478   display_comp->SignalPreCompDone();
 479
 480   return 0;
 481 }
 482
 483 int DrmDisplayCompositor::DisablePlanes(DrmDisplayComposition *display_comp) {
 484   drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
 485   if (!pset) {
 486     ALOGE("Failed to allocate property set");
 487     return -ENOMEM;
 488   }
 489
 490   int ret;
 491   std::vector<DrmCompositionPlane> &comp_planes =
 492       display_comp->composition_planes();
 493   for (DrmCompositionPlane &comp_plane : comp_planes) {
 494     DrmPlane *plane = comp_plane.plane();
 495     ret = drmModeAtomicAddProperty(pset, plane->id(),
 496                                    plane->crtc_property().id(), 0) < 0 ||
 497           drmModeAtomicAddProperty(pset, plane->id(), plane->fb_property().id(),
 498                                    0) < 0;
 499     if (ret) {
 500       ALOGE("Failed to add plane %d disable to pset", plane->id());
 501       drmModeAtomicFree(pset);
 502       return ret;
 503     }
 504   }
 505
 506   ret = drmModeAtomicCommit(drm_->fd(), pset, 0, drm_);
 507   if (ret) {
 508     ALOGE("Failed to commit pset ret=%d\n", ret);
 509     drmModeAtomicFree(pset);
 510     return ret;
 511   }
 512
 513   drmModeAtomicFree(pset);
 514   return 0;
 515 }
 516
 517 int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) {
 518   int ret = 0;
 519
 520   std::vector<DrmHwcLayer> &layers = display_comp->layers();
 521   std::vector<DrmCompositionPlane> &comp_planes =
 522       display_comp->composition_planes();
 523   std::vector<DrmCompositionRegion> &squash_regions =
 524       display_comp->squash_regions();
 525   std::vector<DrmCompositionRegion> &pre_comp_regions =
 526       display_comp->pre_comp_regions();
 527
 528   int squash_layer_index = -1;
 529   if (squash_regions.size() > 0) {
 530     squash_framebuffer_index_ = (squash_framebuffer_index_ + 1) % 2;
 531     ret = ApplySquash(display_comp);
 532     if (ret)
 533       return ret;
 534
 535     squash_layer_index = layers.size() - 1;
 536   } else {
 537     if (UsesSquash(comp_planes)) {
 538       DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_];
 539       layers.emplace_back();
 540       squash_layer_index = layers.size() - 1;
 541       DrmHwcLayer &squash_layer = layers.back();
 542       ret = squash_layer.buffer.ImportBuffer(fb.buffer()->handle,
 543                                              display_comp->importer());
 544       if (ret) {
 545         ALOGE("Failed to import old squashed framebuffer %d", ret);
 546         return ret;
 547       }
 548       squash_layer.sf_handle = fb.buffer()->handle;
 549       squash_layer.blending = DrmHwcBlending::kPreMult;
 550       squash_layer.source_crop = DrmHwcRect<float>(
 551           0, 0, squash_layer.buffer->width, squash_layer.buffer->height);
 552       squash_layer.display_frame = DrmHwcRect<int>(
 553           0, 0, squash_layer.buffer->width, squash_layer.buffer->height);
 554       ret = display_comp->CreateNextTimelineFence();
 555
 556       if (ret <= 0) {
 557         ALOGE("Failed to create squash framebuffer release fence %d", ret);
 558         return ret;
 559       }
 560
 561       fb.set_release_fence_fd(ret);
 562       ret = 0;
 563     }
 564   }
 565
 566   bool do_pre_comp = pre_comp_regions.size() > 0;
 567   int pre_comp_layer_index = -1;
 568   if (do_pre_comp) {
 569     ret = ApplyPreComposite(display_comp);
 570     if (ret)
 571       return ret;
 572
 573     pre_comp_layer_index = layers.size() - 1;
 574     framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
 575   }
 576
 577   for (DrmCompositionPlane &comp_plane : comp_planes) {
 578     std::vector<size_t> &source_layers = comp_plane.source_layers();
 579     switch (comp_plane.type()) {
 580       case DrmCompositionPlane::Type::kSquash:
 581         if (source_layers.size())
 582           ALOGE("Squash source_layers is expected to be empty (%zu/%d)",
 583                 source_layers[0], squash_layer_index);
 584         source_layers.push_back(squash_layer_index);
 585         break;
 586       case DrmCompositionPlane::Type::kPrecomp:
 587         if (!do_pre_comp) {
 588           ALOGE(
 589               "Can not use pre composite framebuffer with no pre composite "
 590               "regions");
 591           return -EINVAL;
 592         }
 593         // Replace source_layers with the output of the precomposite
 594         source_layers.clear();
 595         source_layers.push_back(pre_comp_layer_index);
 596         break;
 597       default:
 598         break;
 599     }
 600   }
 601
 602   return ret;
 603 }
 604
 605 int DrmDisplayCompositor::CommitFrame(DrmDisplayComposition *display_comp,
 606                                       bool test_only) {
 607   ATRACE_CALL();
 608
 609   int ret = 0;
 610
 611   std::vector<DrmHwcLayer> &layers = display_comp->layers();
 612   std::vector<DrmCompositionPlane> &comp_planes =
 613       display_comp->composition_planes();
 614   uint64_t out_fences[drm_->crtcs().size()];
 615
 616   DrmConnector *connector = drm_->GetConnectorForDisplay(display_);
 617   if (!connector) {
 618     ALOGE("Could not locate connector for display %d", display_);
 619     return -ENODEV;
 620   }
 621   DrmCrtc *crtc = drm_->GetCrtcForDisplay(display_);
 622   if (!crtc) {
 623     ALOGE("Could not locate crtc for display %d", display_);
 624     return -ENODEV;
 625   }
 626
 627   drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
 628   if (!pset) {
 629     ALOGE("Failed to allocate property set");
 630     return -ENOMEM;
 631   }
 632
 633   if (crtc->out_fence_ptr_property().id() != 0) {
 634     ret = drmModeAtomicAddProperty(pset, crtc->id(), crtc->out_fence_ptr_property().id(),
 635                                    (uint64_t) &out_fences[crtc->pipe()]);
 636     if (ret < 0) {
 637       ALOGE("Failed to add OUT_FENCE_PTR property to pset: %d", ret);
 638       drmModeAtomicFree(pset);
 639       return ret;
 640     }
 641   }
 642
 643   if (mode_.needs_modeset) {
 644     ret = drmModeAtomicAddProperty(pset, crtc->id(), crtc->active_property().id(), 1);
 645     if (ret < 0) {
 646       ALOGE("Failed to add crtc active to pset\n");
 647       drmModeAtomicFree(pset);
 648       return ret;
 649     }
 650
 651     ret = drmModeAtomicAddProperty(pset, crtc->id(), crtc->mode_property().id(),
 652                                    mode_.blob_id) < 0 ||
 653           drmModeAtomicAddProperty(pset, connector->id(),
 654                                    connector->crtc_id_property().id(),
 655                                    crtc->id()) < 0;
 656     if (ret) {
 657       ALOGE("Failed to add blob %d to pset", mode_.blob_id);
 658       drmModeAtomicFree(pset);
 659       return ret;
 660     }
 661   }
 662
 663   for (DrmCompositionPlane &comp_plane : comp_planes) {
 664     DrmPlane *plane = comp_plane.plane();
 665     DrmCrtc *crtc = comp_plane.crtc();
 666     std::vector<size_t> &source_layers = comp_plane.source_layers();
 667
 668     int fb_id = -1;
 669     int fence_fd = -1;
 670     DrmHwcRect<int> display_frame;
 671     DrmHwcRect<float> source_crop;
 672     uint64_t rotation = 0;
 673     uint64_t alpha = 0xFF;
 674
 675     if (comp_plane.type() != DrmCompositionPlane::Type::kDisable) {
 676       if (source_layers.size() > 1) {
 677         ALOGE("Can't handle more than one source layer sz=%zu type=%d",
 678               source_layers.size(), comp_plane.type());
 679         continue;
 680       }
 681
 682       if (source_layers.empty() || source_layers.front() >= layers.size()) {
 683         ALOGE("Source layer index %zu out of bounds %zu type=%d",
 684               source_layers.front(), layers.size(), comp_plane.type());
 685         break;
 686       }
 687       DrmHwcLayer &layer = layers[source_layers.front()];
 688       if (!layer.buffer) {
 689         ALOGE("Expected a valid framebuffer for pset");
 690         break;
 691       }
 692       fb_id = layer.buffer->fb_id;
 693       fence_fd = layer.acquire_fence.get();
 694       display_frame = layer.display_frame;
 695       source_crop = layer.source_crop;
 696       if (layer.blending == DrmHwcBlending::kPreMult)
 697         alpha = layer.alpha;
 698
 699       rotation = 0;
 700       if (layer.transform & DrmHwcTransform::kFlipH)
 701         rotation |= DRM_MODE_REFLECT_X;
 702       if (layer.transform & DrmHwcTransform::kFlipV)
 703         rotation |= DRM_MODE_REFLECT_Y;
 704       if (layer.transform & DrmHwcTransform::kRotate90)
 705         rotation |= DRM_MODE_ROTATE_90;
 706       else if (layer.transform & DrmHwcTransform::kRotate180)
 707         rotation |= DRM_MODE_ROTATE_180;
 708       else if (layer.transform & DrmHwcTransform::kRotate270)
 709         rotation |= DRM_MODE_ROTATE_270;
 710       else
 711         rotation |= DRM_MODE_ROTATE_0;
 712
 713       if (fence_fd >= 0) {
 714         int prop_id = plane->in_fence_fd_property().id();
 715         if (prop_id == 0) {
 716                 ALOGE("Failed to get IN_FENCE_FD property id");
 717                 break;
 718         }
 719         ret = drmModeAtomicAddProperty(pset, plane->id(), prop_id, fence_fd);
 720         if (ret < 0) {
 721           ALOGE("Failed to add IN_FENCE_FD property to pset: %d", ret);
 722           break;
 723         }
 724       }
 725     }
 726
 727     // Disable the plane if there's no framebuffer
 728     if (fb_id < 0) {
 729       ret = drmModeAtomicAddProperty(pset, plane->id(),
 730                                      plane->crtc_property().id(), 0) < 0 ||
 731             drmModeAtomicAddProperty(pset, plane->id(),
 732                                      plane->fb_property().id(), 0) < 0;
 733       if (ret) {
 734         ALOGE("Failed to add plane %d disable to pset", plane->id());
 735         break;
 736       }
 737       continue;
 738     }
 739
 740     // TODO: Once we have atomic test, this should fall back to GL
 741     if (rotation != DRM_MODE_ROTATE_0 && plane->rotation_property().id() == 0) {
 742       ALOGE("Rotation is not supported on plane %d", plane->id());
 743       ret = -EINVAL;
 744       break;
 745     }
 746
 747     // TODO: Once we have atomic test, this should fall back to GL
 748     if (alpha != 0xFF && plane->alpha_property().id() == 0) {
 749       ALOGE("Alpha is not supported on plane %d", plane->id());
 750       ret = -EINVAL;
 751       break;
 752     }
 753
 754     ret = drmModeAtomicAddProperty(pset, plane->id(),
 755                                    plane->crtc_property().id(), crtc->id()) < 0;
 756     ret |= drmModeAtomicAddProperty(pset, plane->id(),
 757                                     plane->fb_property().id(), fb_id) < 0;
 758     ret |= drmModeAtomicAddProperty(pset, plane->id(),
 759                                     plane->crtc_x_property().id(),
 760                                     display_frame.left) < 0;
 761     ret |= drmModeAtomicAddProperty(pset, plane->id(),
 762                                     plane->crtc_y_property().id(),
 763                                     display_frame.top) < 0;
 764     ret |= drmModeAtomicAddProperty(
 765                pset, plane->id(), plane->crtc_w_property().id(),
 766                display_frame.right - display_frame.left) < 0;
 767     ret |= drmModeAtomicAddProperty(
 768                pset, plane->id(), plane->crtc_h_property().id(),
 769                display_frame.bottom - display_frame.top) < 0;
 770     ret |= drmModeAtomicAddProperty(pset, plane->id(),
 771                                     plane->src_x_property().id(),
 772                                     (int)(source_crop.left) << 16) < 0;
 773     ret |= drmModeAtomicAddProperty(pset, plane->id(),
 774                                     plane->src_y_property().id(),
 775                                     (int)(source_crop.top) << 16) < 0;
 776     ret |= drmModeAtomicAddProperty(
 777                pset, plane->id(), plane->src_w_property().id(),
 778                (int)(source_crop.right - source_crop.left) << 16) < 0;
 779     ret |= drmModeAtomicAddProperty(
 780                pset, plane->id(), plane->src_h_property().id(),
 781                (int)(source_crop.bottom - source_crop.top) << 16) < 0;
 782     if (ret) {
 783       ALOGE("Failed to add plane %d to set", plane->id());
 784       break;
 785     }
 786
 787     if (plane->rotation_property().id()) {
 788       ret = drmModeAtomicAddProperty(pset, plane->id(),
 789                                      plane->rotation_property().id(),
 790                                      rotation) < 0;
 791       if (ret) {
 792         ALOGE("Failed to add rotation property %d to plane %d",
 793               plane->rotation_property().id(), plane->id());
 794         break;
 795       }
 796     }
 797
 798     if (plane->alpha_property().id()) {
 799       ret = drmModeAtomicAddProperty(pset, plane->id(),
 800                                      plane->alpha_property().id(),
 801                                      alpha) < 0;
 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   if (!ret) {
 811     uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
 812     if (test_only)
 813       flags |= DRM_MODE_ATOMIC_TEST_ONLY;
 814
 815     ret = drmModeAtomicCommit(drm_->fd(), pset, flags, drm_);
 816     if (ret) {
 817       if (test_only)
 818         ALOGI("Commit test pset failed ret=%d\n", ret);
 819       else
 820         ALOGE("Failed to commit pset ret=%d\n", ret);
 821       drmModeAtomicFree(pset);
 822       return ret;
 823     }
 824   }
 825   if (pset)
 826     drmModeAtomicFree(pset);
 827
 828   if (!test_only && mode_.needs_modeset) {
 829     ret = drm_->DestroyPropertyBlob(mode_.old_blob_id);
 830     if (ret) {
 831       ALOGE("Failed to destroy old mode property blob %" PRIu32 "/%d",
 832             mode_.old_blob_id, ret);
 833       return ret;
 834     }
 835
 836     /* TODO: Add dpms to the pset when the kernel supports it */
 837     ret = ApplyDpms(display_comp);
 838     if (ret) {
 839       ALOGE("Failed to apply DPMS after modeset %d\n", ret);
 840       return ret;
 841     }
 842
 843     connector->set_active_mode(mode_.mode);
 844     mode_.old_blob_id = mode_.blob_id;
 845     mode_.blob_id = 0;
 846     mode_.needs_modeset = false;
 847   }
 848
 849   if (crtc->out_fence_ptr_property().id()) {
 850     display_comp->set_out_fence((int) out_fences[crtc->pipe()]);
 851   }
 852
 853   return ret;
 854 }
 855
 856 int DrmDisplayCompositor::ApplyDpms(DrmDisplayComposition *display_comp) {
 857   DrmConnector *conn = drm_->GetConnectorForDisplay(display_);
 858   if (!conn) {
 859     ALOGE("Failed to get DrmConnector for display %d", display_);
 860     return -ENODEV;
 861   }
 862
 863   const DrmProperty &prop = conn->dpms_property();
 864   int ret = drmModeConnectorSetProperty(drm_->fd(), conn->id(), prop.id(),
 865                                         display_comp->dpms_mode());
 866   if (ret) {
 867     ALOGE("Failed to set DPMS property for connector %d", conn->id());
 868     return ret;
 869   }
 870   return 0;
 871 }
 872
 873 std::tuple<int, uint32_t> DrmDisplayCompositor::CreateModeBlob(
 874     const DrmMode &mode) {
 875   struct drm_mode_modeinfo drm_mode;
 876   memset(&drm_mode, 0, sizeof(drm_mode));
 877   mode.ToDrmModeModeInfo(&drm_mode);
 878
 879   uint32_t id = 0;
 880   int ret = drm_->CreatePropertyBlob(&drm_mode,
 881                                      sizeof(struct drm_mode_modeinfo), &id);
 882   if (ret) {
 883     ALOGE("Failed to create mode property blob %d", ret);
 884     return std::make_tuple(ret, 0);
 885   }
 886   ALOGE("Create blob_id %" PRIu32 "\n", id);
 887   return std::make_tuple(ret, id);
 888 }
 889
 890 void DrmDisplayCompositor::ClearDisplay() {
 891   AutoLock lock(&lock_, "compositor");
 892   int ret = lock.Lock();
 893   if (ret)
 894     return;
 895
 896   if (!active_composition_)
 897     return;
 898
 899   if (DisablePlanes(active_composition_.get()))
 900     return;
 901
 902   active_composition_->SignalCompositionDone();
 903
 904   active_composition_.reset(NULL);
 905 }
 906
 907 void DrmDisplayCompositor::ApplyFrame(
 908     std::unique_ptr<DrmDisplayComposition> composition, int status) {
 909   int ret = status;
 910
 911   if (!ret)
 912     ret = CommitFrame(composition.get(), false);
 913
 914   if (ret) {
 915     ALOGE("Composite failed for display %d", display_);
 916     // Disable the hw used by the last active composition. This allows us to
 917     // signal the release fences from that composition to avoid hanging.
 918     ClearDisplay();
 919     return;
 920   }
 921   ++dump_frames_composited_;
 922
 923   if (active_composition_)
 924     active_composition_->SignalCompositionDone();
 925
 926   ret = pthread_mutex_lock(&lock_);
 927   if (ret)
 928     ALOGE("Failed to acquire lock for active_composition swap");
 929
 930   active_composition_.swap(composition);
 931
 932   if (!ret)
 933     ret = pthread_mutex_unlock(&lock_);
 934   if (ret)
 935     ALOGE("Failed to release lock for active_composition swap");
 936 }
 937
 938 int DrmDisplayCompositor::Composite() {
 939   ATRACE_CALL();
 940
 941   if (!pre_compositor_) {
 942     pre_compositor_.reset(new GLWorkerCompositor());
 943     int ret = pre_compositor_->Init();
 944     if (ret) {
 945       ALOGE("Failed to initialize OpenGL compositor %d", ret);
 946       return ret;
 947     }
 948   }
 949
 950   int ret = pthread_mutex_lock(&lock_);
 951   if (ret) {
 952     ALOGE("Failed to acquire compositor lock %d", ret);
 953     return ret;
 954   }
 955   if (composite_queue_.empty()) {
 956     ret = pthread_mutex_unlock(&lock_);
 957     if (ret)
 958       ALOGE("Failed to release compositor lock %d", ret);
 959     return ret;
 960   }
 961
 962   std::unique_ptr<DrmDisplayComposition> composition(
 963       std::move(composite_queue_.front()));
 964
 965   composite_queue_.pop();
 966
 967   ret = pthread_mutex_unlock(&lock_);
 968   if (ret) {
 969     ALOGE("Failed to release compositor lock %d", ret);
 970     return ret;
 971   }
 972
 973   switch (composition->type()) {
 974     case DRM_COMPOSITION_TYPE_FRAME:
 975       ret = PrepareFrame(composition.get());
 976       if (ret) {
 977         ALOGE("Failed to prepare frame for display %d", display_);
 978         return ret;
 979       }
 980       if (composition->geometry_changed()) {
 981         // Send the composition to the kernel to ensure we can commit it. This
 982         // is just a test, it won't actually commit the frame. If rejected,
 983         // squash the frame into one layer and use the squashed composition
 984         ret = CommitFrame(composition.get(), true);
 985         if (ret)
 986           ALOGI("Commit test failed, squashing frame for display %d", display_);
 987         use_hw_overlays_ = !ret;
 988       }
 989
 990       // If use_hw_overlays_ is false, we can't use hardware to composite the
 991       // frame. So squash all layers into a single composition and queue that
 992       // instead.
 993       if (!use_hw_overlays_) {
 994         std::unique_ptr<DrmDisplayComposition> squashed = CreateComposition();
 995         ret = SquashFrame(composition.get(), squashed.get());
 996         if (!ret) {
 997           composition = std::move(squashed);
 998         } else {
 999           ALOGE("Failed to squash frame for display %d", display_);
1000           // Disable the hw used by the last active composition. This allows us
1001           // to signal the release fences from that composition to avoid
1002           // hanging.
1003           ClearDisplay();
1004           return ret;
1005         }
1006       }
1007       frame_worker_.QueueFrame(std::move(composition), ret);
1008       break;
1009     case DRM_COMPOSITION_TYPE_DPMS:
1010       ret = ApplyDpms(composition.get());
1011       if (ret)
1012         ALOGE("Failed to apply dpms for display %d", display_);
1013       return ret;
1014     case DRM_COMPOSITION_TYPE_MODESET:
1015       mode_.mode = composition->display_mode();
1016       if (mode_.blob_id)
1017         drm_->DestroyPropertyBlob(mode_.blob_id);
1018       std::tie(ret, mode_.blob_id) = CreateModeBlob(mode_.mode);
1019       if (ret) {
1020         ALOGE("Failed to create mode blob for display %d", display_);
1021         return ret;
1022       }
1023       mode_.needs_modeset = true;
1024       return 0;
1025     default:
1026       ALOGE("Unknown composition type %d", composition->type());
1027       return -EINVAL;
1028   }
1029
1030   return ret;
1031 }
1032
1033 bool DrmDisplayCompositor::HaveQueuedComposites() const {
1034   int ret = pthread_mutex_lock(&lock_);
1035   if (ret) {
1036     ALOGE("Failed to acquire compositor lock %d", ret);
1037     return false;
1038   }
1039
1040   bool empty_ret = !composite_queue_.empty();
1041
1042   ret = pthread_mutex_unlock(&lock_);
1043   if (ret) {
1044     ALOGE("Failed to release compositor lock %d", ret);
1045     return false;
1046   }
1047
1048   return empty_ret;
1049 }
1050
1051 int DrmDisplayCompositor::SquashAll() {
1052   AutoLock lock(&lock_, "compositor");
1053   int ret = lock.Lock();
1054   if (ret)
1055     return ret;
1056
1057   if (!active_composition_)
1058     return 0;
1059
1060   std::unique_ptr<DrmDisplayComposition> comp = CreateComposition();
1061   ret = SquashFrame(active_composition_.get(), comp.get());
1062
1063   // ApplyFrame needs the lock
1064   lock.Unlock();
1065
1066   if (!ret)
1067     ApplyFrame(std::move(comp), 0);
1068
1069   return ret;
1070 }
1071
1072 // Returns:
1073 //   - 0 if src is successfully squashed into dst
1074 //   - -EALREADY if the src is already squashed
1075 //   - Appropriate error if the squash fails
1076 int DrmDisplayCompositor::SquashFrame(DrmDisplayComposition *src,
1077                                       DrmDisplayComposition *dst) {
1078   if (src->type() != DRM_COMPOSITION_TYPE_FRAME)
1079     return -ENOTSUP;
1080
1081   std::vector<DrmCompositionPlane> &src_planes = src->composition_planes();
1082   std::vector<DrmHwcLayer> &src_layers = src->layers();
1083
1084   // Make sure there is more than one layer to squash.
1085   size_t src_planes_with_layer = std::count_if(
1086       src_planes.begin(), src_planes.end(), [](DrmCompositionPlane &p) {
1087         return p.type() != DrmCompositionPlane::Type::kDisable;
1088       });
1089   if (src_planes_with_layer <= 1)
1090     return -EALREADY;
1091
1092   int pre_comp_layer_index;
1093
1094   int ret = dst->Init(drm_, src->crtc(), src->importer(), src->planner(),
1095                       src->frame_no());
1096   if (ret) {
1097     ALOGE("Failed to init squash all composition %d", ret);
1098     return ret;
1099   }
1100
1101   DrmCompositionPlane squashed_comp(DrmCompositionPlane::Type::kPrecomp, NULL,
1102                                     src->crtc());
1103   std::vector<DrmHwcLayer> dst_layers;
1104   for (DrmCompositionPlane &comp_plane : src_planes) {
1105     // Composition planes without DRM planes should never happen
1106     if (comp_plane.plane() == NULL) {
1107       ALOGE("Skipping squash all because of NULL plane");
1108       ret = -EINVAL;
1109       goto move_layers_back;
1110     }
1111
1112     if (comp_plane.plane()->type() == DRM_PLANE_TYPE_PRIMARY)
1113       squashed_comp.set_plane(comp_plane.plane());
1114     else
1115       dst->AddPlaneDisable(comp_plane.plane());
1116
1117     if (comp_plane.type() == DrmCompositionPlane::Type::kDisable)
1118       continue;
1119
1120     for (auto i : comp_plane.source_layers()) {
1121       DrmHwcLayer &layer = src_layers[i];
1122
1123       // Squashing protected layers is impossible.
1124       if (layer.protected_usage()) {
1125         ret = -ENOTSUP;
1126         goto move_layers_back;
1127       }
1128
1129       // The OutputFds point to freed memory after hwc_set returns. They are
1130       // returned to the default to prevent DrmDisplayComposition::Plan from
1131       // filling the OutputFds.
1132       layer.release_fence = OutputFd();
1133       dst_layers.emplace_back(std::move(layer));
1134       squashed_comp.source_layers().push_back(
1135           squashed_comp.source_layers().size());
1136     }
1137   }
1138
1139   if (squashed_comp.plane() == NULL) {
1140     ALOGE("Primary plane not found for squash");
1141     ret = -ENOTSUP;
1142     goto move_layers_back;
1143   }
1144
1145   ret = dst->SetLayers(dst_layers.data(), dst_layers.size(), false);
1146   if (ret) {
1147     ALOGE("Failed to set layers for squash all composition %d", ret);
1148     goto move_layers_back;
1149   }
1150
1151   ret = dst->AddPlaneComposition(std::move(squashed_comp));
1152   if (ret) {
1153     ALOGE("Failed to add squashed plane composition %d", ret);
1154     goto move_layers_back;
1155   }
1156
1157   ret = dst->FinalizeComposition();
1158   if (ret) {
1159     ALOGE("Failed to plan for squash all composition %d", ret);
1160     goto move_layers_back;
1161   }
1162
1163   ret = ApplyPreComposite(dst);
1164   if (ret) {
1165     ALOGE("Failed to pre-composite for squash all composition %d", ret);
1166     goto move_layers_back;
1167   }
1168
1169   pre_comp_layer_index = dst->layers().size() - 1;
1170   framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
1171
1172   for (DrmCompositionPlane &plane : dst->composition_planes()) {
1173     if (plane.type() == DrmCompositionPlane::Type::kPrecomp) {
1174       // Replace source_layers with the output of the precomposite
1175       plane.source_layers().clear();
1176       plane.source_layers().push_back(pre_comp_layer_index);
1177       break;
1178     }
1179   }
1180
1181   return 0;
1182
1183 // TODO(zachr): think of a better way to transfer ownership back to the active
1184 // composition.
1185 move_layers_back:
1186   for (size_t plane_index = 0;
1187        plane_index < src_planes.size() && plane_index < dst_layers.size();) {
1188     if (src_planes[plane_index].source_layers().empty()) {
1189       plane_index++;
1190       continue;
1191     }
1192     for (auto i : src_planes[plane_index].source_layers())
1193       src_layers[i] = std::move(dst_layers[plane_index++]);
1194   }
1195
1196   return ret;
1197 }
1198
1199 void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
1200   int ret = pthread_mutex_lock(&lock_);
1201   if (ret)
1202     return;
1203
1204   uint64_t num_frames = dump_frames_composited_;
1205   dump_frames_composited_ = 0;
1206
1207   struct timespec ts;
1208   ret = clock_gettime(CLOCK_MONOTONIC, &ts);
1209   if (ret) {
1210     pthread_mutex_unlock(&lock_);
1211     return;
1212   }
1213
1214   uint64_t cur_ts = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
1215   uint64_t num_ms = (cur_ts - dump_last_timestamp_ns_) / (1000 * 1000);
1216   float fps = num_ms ? (num_frames * 1000.0f) / (num_ms) : 0.0f;
1217
1218   *out << "--DrmDisplayCompositor[" << display_
1219        << "]: num_frames=" << num_frames << " num_ms=" << num_ms
1220        << " fps=" << fps << "\n";
1221
1222   dump_last_timestamp_ns_ = cur_ts;
1223
1224   if (active_composition_)
1225     active_composition_->Dump(out);
1226
1227   squash_state_.Dump(out);
1228
1229   pthread_mutex_unlock(&lock_);
1230 }
1231 }