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
  25 #include <pthread.h>
  26 #include <sstream>
  27 #include <stdlib.h>
  28 #include <time.h>
  29 #include <vector>
  30
  31 #include <cutils/log.h>
  32 #include <sync/sync.h>
  33 #include <utils/Trace.h>
  34
  35 namespace android {
  36
  37 DrmDisplayCompositor::DrmDisplayCompositor()
  38     : drm_(NULL),
  39       display_(-1),
  40       worker_(this),
  41       frame_no_(0),
  42       initialized_(false),
  43       active_(false),
  44       dump_frames_composited_(0),
  45       dump_last_timestamp_ns_(0) {
  46   struct timespec ts;
  47   if (clock_gettime(CLOCK_MONOTONIC, &ts))
  48     return;
  49   dump_last_timestamp_ns_ = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
  50 }
  51
  52 DrmDisplayCompositor::~DrmDisplayCompositor() {
  53   if (!initialized_)
  54     return;
  55
  56   worker_.Exit();
  57
  58   int ret = pthread_mutex_lock(&lock_);
  59   if (ret)
  60     ALOGE("Failed to acquire compositor lock %d", ret);
  61
  62   while (!composite_queue_.empty()) {
  63     composite_queue_.front().reset();
  64     composite_queue_.pop();
  65   }
  66   active_composition_.reset();
  67
  68   ret = pthread_mutex_unlock(&lock_);
  69   if (ret)
  70     ALOGE("Failed to acquire compositor lock %d", ret);
  71
  72   pthread_mutex_destroy(&lock_);
  73 }
  74
  75 int DrmDisplayCompositor::Init(DrmResources *drm, int display) {
  76   drm_ = drm;
  77   display_ = display;
  78
  79   int ret = pthread_mutex_init(&lock_, NULL);
  80   if (ret) {
  81     ALOGE("Failed to initialize drm compositor lock %d\n", ret);
  82     return ret;
  83   }
  84   ret = worker_.Init();
  85   if (ret) {
  86     pthread_mutex_destroy(&lock_);
  87     ALOGE("Failed to initialize compositor worker %d\n", ret);
  88     return ret;
  89   }
  90
  91   initialized_ = true;
  92   return 0;
  93 }
  94
  95 int DrmDisplayCompositor::QueueComposition(
  96     std::unique_ptr<DrmDisplayComposition> composition) {
  97   switch (composition->type()) {
  98   case DRM_COMPOSITION_TYPE_FRAME:
  99     if (!active_)
 100       return -ENODEV;
 101     break;
 102   case DRM_COMPOSITION_TYPE_DPMS:
 103     /*
 104      * Update the state as soon as we get it so we can start/stop queuing
 105      * frames asap.
 106      */
 107     active_ = (composition->dpms_mode() == DRM_MODE_DPMS_ON);
 108     break;
 109   case DRM_COMPOSITION_TYPE_EMPTY:
 110     return 0;
 111   default:
 112     ALOGE("Unknown composition type %d/%d", composition->type(), display_);
 113     return -ENOENT;
 114   }
 115
 116   int ret = pthread_mutex_lock(&lock_);
 117   if (ret) {
 118     ALOGE("Failed to acquire compositor lock %d", ret);
 119     return ret;
 120   }
 121
 122   composite_queue_.push(std::move(composition));
 123
 124   ret = pthread_mutex_unlock(&lock_);
 125   if (ret) {
 126     ALOGE("Failed to release compositor lock %d", ret);
 127     return ret;
 128   }
 129
 130   worker_.Signal();
 131   return 0;
 132 }
 133
 134 int DrmDisplayCompositor::ApplyFrame(DrmDisplayComposition *display_comp) {
 135   int ret = 0;
 136
 137   drmModePropertySetPtr pset = drmModePropertySetAlloc();
 138   if (!pset) {
 139     ALOGE("Failed to allocate property set");
 140     return -ENOMEM;
 141   }
 142
 143   DrmCompositionLayerVector_t *layers = display_comp->GetCompositionLayers();
 144   for (DrmCompositionLayerVector_t::iterator iter = layers->begin();
 145        iter != layers->end(); ++iter) {
 146     hwc_layer_1_t *layer = &iter->layer;
 147
 148     if (layer->acquireFenceFd >= 0) {
 149       ret = sync_wait(layer->acquireFenceFd, -1);
 150       if (ret) {
 151         ALOGE("Failed to wait for acquire %d/%d", layer->acquireFenceFd, ret);
 152         drmModePropertySetFree(pset);
 153         return ret;
 154       }
 155       close(layer->acquireFenceFd);
 156       layer->acquireFenceFd = -1;
 157     }
 158
 159     DrmPlane *plane = iter->plane;
 160     DrmCrtc *crtc = iter->crtc;
 161
 162     // Disable the plane if there's no crtc
 163     if (!crtc) {
 164       ret =
 165           drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(),
 166                                 0) ||
 167           drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(),
 168                                 0);
 169       if (ret) {
 170         ALOGE("Failed to add plane %d disable to pset", plane->id());
 171         break;
 172       }
 173       continue;
 174     }
 175
 176     ret =
 177         drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(),
 178                               crtc->id()) ||
 179         drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(),
 180                               iter->bo.fb_id) ||
 181         drmModePropertySetAdd(pset, plane->id(), plane->crtc_x_property().id(),
 182                               layer->displayFrame.left) ||
 183         drmModePropertySetAdd(pset, plane->id(), plane->crtc_y_property().id(),
 184                               layer->displayFrame.top) ||
 185         drmModePropertySetAdd(
 186             pset, plane->id(), plane->crtc_w_property().id(),
 187             layer->displayFrame.right - layer->displayFrame.left) ||
 188         drmModePropertySetAdd(
 189             pset, plane->id(), plane->crtc_h_property().id(),
 190             layer->displayFrame.bottom - layer->displayFrame.top) ||
 191         drmModePropertySetAdd(pset, plane->id(), plane->src_x_property().id(),
 192                               (int)(layer->sourceCropf.left) << 16) ||
 193         drmModePropertySetAdd(pset, plane->id(), plane->src_y_property().id(),
 194                               (int)(layer->sourceCropf.top) << 16) ||
 195         drmModePropertySetAdd(
 196             pset, plane->id(), plane->src_w_property().id(),
 197             (int)(layer->sourceCropf.right - layer->sourceCropf.left) << 16) ||
 198         drmModePropertySetAdd(
 199             pset, plane->id(), plane->src_h_property().id(),
 200             (int)(layer->sourceCropf.bottom - layer->sourceCropf.top) << 16);
 201     if (ret) {
 202       ALOGE("Failed to add plane %d to set", plane->id());
 203       break;
 204     }
 205   }
 206
 207   if (!ret) {
 208     ret = drmModePropertySetCommit(drm_->fd(), 0, drm_, pset);
 209     if (ret)
 210       ALOGE("Failed to commit pset ret=%d\n", ret);
 211   }
 212   if (pset)
 213     drmModePropertySetFree(pset);
 214
 215   return ret;
 216 }
 217
 218 int DrmDisplayCompositor::ApplyDpms(DrmDisplayComposition *display_comp) {
 219   DrmConnector *conn = drm_->GetConnectorForDisplay(display_);
 220   if (!conn) {
 221     ALOGE("Failed to get DrmConnector for display %d", display_);
 222     return -ENODEV;
 223   }
 224
 225   const DrmProperty &prop = conn->dpms_property();
 226   int ret = drmModeConnectorSetProperty(drm_->fd(), conn->id(), prop.id(),
 227                                         display_comp->dpms_mode());
 228   if (ret) {
 229     ALOGE("Failed to set DPMS property for connector %d", conn->id());
 230     return ret;
 231   }
 232   return 0;
 233 }
 234
 235 int DrmDisplayCompositor::Composite() {
 236   ATRACE_CALL();
 237   int ret = pthread_mutex_lock(&lock_);
 238   if (ret) {
 239     ALOGE("Failed to acquire compositor lock %d", ret);
 240     return ret;
 241   }
 242   if (composite_queue_.empty()) {
 243     ret = pthread_mutex_unlock(&lock_);
 244     if (ret)
 245       ALOGE("Failed to release compositor lock %d", ret);
 246     return ret;
 247   }
 248
 249   std::unique_ptr<DrmDisplayComposition> composition(
 250       std::move(composite_queue_.front()));
 251   composite_queue_.pop();
 252
 253   ret = pthread_mutex_unlock(&lock_);
 254   if (ret) {
 255     ALOGE("Failed to release compositor lock %d", ret);
 256     return ret;
 257   }
 258
 259   switch (composition->type()) {
 260   case DRM_COMPOSITION_TYPE_FRAME:
 261     ret = ApplyFrame(composition.get());
 262     if (ret) {
 263       ALOGE("Composite failed for display %d", display_);
 264       return ret;
 265     }
 266     ++dump_frames_composited_;
 267     break;
 268   case DRM_COMPOSITION_TYPE_DPMS:
 269     ret = ApplyDpms(composition.get());
 270     if (ret)
 271       ALOGE("Failed to apply dpms for display %d", display_);
 272     return ret;
 273   default:
 274     ALOGE("Unknown composition type %d", composition->type());
 275     return -EINVAL;
 276   }
 277
 278   if (active_composition_)
 279     active_composition_->FinishComposition();
 280
 281   ret = pthread_mutex_lock(&lock_);
 282   if (ret)
 283     ALOGE("Failed to acquire lock for active_composition swap");
 284
 285   active_composition_.swap(composition);
 286
 287   if (!ret)
 288     ret = pthread_mutex_unlock(&lock_);
 289     if (ret)
 290       ALOGE("Failed to release lock for active_composition swap");
 291
 292   return ret;
 293 }
 294
 295 bool DrmDisplayCompositor::HaveQueuedComposites() const {
 296   int ret = pthread_mutex_lock(&lock_);
 297   if (ret) {
 298     ALOGE("Failed to acquire compositor lock %d", ret);
 299     return false;
 300   }
 301
 302   bool empty_ret = !composite_queue_.empty();
 303
 304   ret = pthread_mutex_unlock(&lock_);
 305   if (ret) {
 306     ALOGE("Failed to release compositor lock %d", ret);
 307     return false;
 308   }
 309
 310   return empty_ret;
 311 }
 312
 313 void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
 314   uint64_t cur_ts;
 315
 316   int ret = pthread_mutex_lock(&lock_);
 317   if (ret)
 318     return;
 319
 320   uint64_t num_frames = dump_frames_composited_;
 321   dump_frames_composited_ = 0;
 322
 323   struct timespec ts;
 324   ret = clock_gettime(CLOCK_MONOTONIC, &ts);
 325
 326   DrmCompositionLayerVector_t layers;
 327   if (active_composition_)
 328     layers = *active_composition_->GetCompositionLayers();
 329   else
 330     ret = -EAGAIN;
 331
 332   ret |= pthread_mutex_unlock(&lock_);
 333   if (ret)
 334     return;
 335
 336   cur_ts = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
 337   uint64_t num_ms = (cur_ts - dump_last_timestamp_ns_) / (1000 * 1000);
 338   float fps = num_ms ? (num_frames * 1000.0f) / (num_ms) : 0.0f;
 339
 340   *out << "--DrmDisplayCompositor[" << display_
 341        << "]: num_frames=" << num_frames << " num_ms=" << num_ms
 342        << " fps=" << fps << "\n";
 343
 344   dump_last_timestamp_ns_ = cur_ts;
 345
 346   *out << "---- DrmDisplayCompositor Layers: num=" << layers.size() << "\n";
 347   for (DrmCompositionLayerVector_t::iterator iter = layers.begin();
 348        iter != layers.end(); ++iter) {
 349     hwc_layer_1_t *layer = &iter->layer;
 350     DrmPlane *plane = iter->plane;
 351
 352     *out << "------ DrmDisplayCompositor Layer: plane=" << plane->id() << " ";
 353
 354     DrmCrtc *crtc = iter->crtc;
 355     if (!crtc) {
 356       *out << "disabled\n";
 357       continue;
 358     }
 359
 360     *out << "crtc=" << crtc->id() << " crtc[x/y/w/h]=" <<
 361         layer->displayFrame.left << "/" << layer->displayFrame.top << "/" <<
 362         layer->displayFrame.right - layer->displayFrame.left << "/" <<
 363         layer->displayFrame.bottom - layer->displayFrame.top << " " <<
 364         " src[x/y/w/h]=" << layer->sourceCropf.left << "/" <<
 365         layer->sourceCropf.top << "/" <<
 366         layer->sourceCropf.right - layer->sourceCropf.left << "/" <<
 367         layer->sourceCropf.bottom - layer->sourceCropf.top << "\n";
 368   }
 369
 370 }
 371 }