Home | History | Annotate | Download | only in drm_hwcomposer 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "hwc-platform"
     18 
     19 #include "drmresources.h"
     20 #include "platform.h"
     21 
     22 #include <cutils/log.h>
     23 
     24 namespace android {
     25 
     26 std::vector<DrmPlane *> Planner::GetUsablePlanes(
     27     DrmCrtc *crtc, std::vector<DrmPlane *> *primary_planes,
     28     std::vector<DrmPlane *> *overlay_planes) {
     29   std::vector<DrmPlane *> usable_planes;
     30   std::copy_if(primary_planes->begin(), primary_planes->end(),
     31                std::back_inserter(usable_planes),
     32                [=](DrmPlane *plane) { return plane->GetCrtcSupported(*crtc); });
     33   std::copy_if(overlay_planes->begin(), overlay_planes->end(),
     34                std::back_inserter(usable_planes),
     35                [=](DrmPlane *plane) { return plane->GetCrtcSupported(*crtc); });
     36   return usable_planes;
     37 }
     38 
     39 std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
     40     std::map<size_t, DrmHwcLayer *> &layers, bool use_squash_fb, DrmCrtc *crtc,
     41     std::vector<DrmPlane *> *primary_planes,
     42     std::vector<DrmPlane *> *overlay_planes) {
     43   std::vector<DrmCompositionPlane> composition;
     44   std::vector<DrmPlane *> planes =
     45       GetUsablePlanes(crtc, primary_planes, overlay_planes);
     46   if (planes.empty()) {
     47     ALOGE("Display %d has no usable planes", crtc->display());
     48     return std::make_tuple(-ENODEV, std::vector<DrmCompositionPlane>());
     49   }
     50 
     51   // If needed, reserve the squash plane at the highest z-order
     52   DrmPlane *squash_plane = NULL;
     53   if (use_squash_fb) {
     54     if (!planes.empty()) {
     55       squash_plane = planes.back();
     56       planes.pop_back();
     57     } else {
     58       ALOGI("Not enough planes to reserve for squash fb");
     59     }
     60   }
     61 
     62   // If needed, reserve the precomp plane at the next highest z-order
     63   DrmPlane *precomp_plane = NULL;
     64   if (layers.size() > planes.size()) {
     65     if (!planes.empty()) {
     66       precomp_plane = planes.back();
     67       planes.pop_back();
     68       composition.emplace_back(DrmCompositionPlane::Type::kPrecomp,
     69                                precomp_plane, crtc);
     70     } else {
     71       ALOGE("Not enough planes to reserve for precomp fb");
     72     }
     73   }
     74 
     75   // Go through the provisioning stages and provision planes
     76   for (auto &i : stages_) {
     77     int ret = i->ProvisionPlanes(&composition, layers, crtc, &planes);
     78     if (ret) {
     79       ALOGE("Failed provision stage with ret %d", ret);
     80       return std::make_tuple(ret, std::vector<DrmCompositionPlane>());
     81     }
     82   }
     83 
     84   if (squash_plane)
     85     composition.emplace_back(DrmCompositionPlane::Type::kSquash, squash_plane,
     86                              crtc);
     87 
     88   return std::make_tuple(0, std::move(composition));
     89 }
     90 
     91 int PlanStageProtected::ProvisionPlanes(
     92     std::vector<DrmCompositionPlane> *composition,
     93     std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
     94     std::vector<DrmPlane *> *planes) {
     95   int ret;
     96   int protected_zorder = -1;
     97   for (auto i = layers.begin(); i != layers.end();) {
     98     if (!i->second->protected_usage()) {
     99       ++i;
    100       continue;
    101     }
    102 
    103     ret = Emplace(composition, planes, DrmCompositionPlane::Type::kLayer, crtc,
    104                   i->first);
    105     if (ret)
    106       ALOGE("Failed to dedicate protected layer! Dropping it.");
    107 
    108     protected_zorder = i->first;
    109     i = layers.erase(i);
    110   }
    111 
    112   if (protected_zorder == -1)
    113     return 0;
    114 
    115   // Add any layers below the protected content to the precomposition since we
    116   // need to punch a hole through them.
    117   for (auto i = layers.begin(); i != layers.end();) {
    118     // Skip layers above the z-order of the protected content
    119     if (i->first > static_cast<size_t>(protected_zorder)) {
    120       ++i;
    121       continue;
    122     }
    123 
    124     // If there's no precomp layer already queued, queue one now.
    125     DrmCompositionPlane *precomp = GetPrecomp(composition);
    126     if (precomp) {
    127       precomp->source_layers().emplace_back(i->first);
    128     } else {
    129       if (!planes->empty()) {
    130         DrmPlane *precomp_plane = planes->back();
    131         planes->pop_back();
    132         composition->emplace_back(DrmCompositionPlane::Type::kPrecomp,
    133                                   precomp_plane, crtc, i->first);
    134       } else {
    135         ALOGE("Not enough planes to reserve for precomp fb");
    136       }
    137     }
    138     i = layers.erase(i);
    139   }
    140   return 0;
    141 }
    142 
    143 int PlanStagePrecomp::ProvisionPlanes(
    144     std::vector<DrmCompositionPlane> *composition,
    145     std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
    146     std::vector<DrmPlane *> *planes) {
    147   DrmCompositionPlane *precomp = GetPrecomp(composition);
    148   if (!precomp || precomp->source_layers().empty())
    149     return 0;
    150 
    151   // Find lowest zorder out of precomp layers
    152   size_t precomp_zorder = *std::min_element(
    153       precomp->source_layers().begin(), precomp->source_layers().end(),
    154       [](size_t a, size_t b) { return a < b; });
    155 
    156   // if there are any remaining layers on top of any of the precomp layers,
    157   // add them to precomp to avoid blending issues since precomp is always at
    158   // highest zorder
    159   for (auto i = layers.begin(); i != layers.end();) {
    160     if (i->first < precomp_zorder) {
    161       i++;
    162       continue;
    163     }
    164     precomp->source_layers().emplace_back(i->first);
    165     i = layers.erase(i);
    166   }
    167 
    168   return 0;
    169 }
    170 
    171 int PlanStageGreedy::ProvisionPlanes(
    172     std::vector<DrmCompositionPlane> *composition,
    173     std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
    174     std::vector<DrmPlane *> *planes) {
    175   // Fill up the remaining planes
    176   for (auto i = layers.begin(); i != layers.end(); i = layers.erase(i)) {
    177     int ret = Emplace(composition, planes, DrmCompositionPlane::Type::kLayer,
    178                       crtc, i->first);
    179     // We don't have any planes left
    180     if (ret == -ENOENT)
    181       break;
    182     else if (ret)
    183       ALOGE("Failed to emplace layer %zu, dropping it", i->first);
    184   }
    185 
    186   // Put the rest of the layers in the precomp plane
    187   DrmCompositionPlane *precomp = GetPrecomp(composition);
    188   if (precomp) {
    189     for (auto i = layers.begin(); i != layers.end(); i = layers.erase(i))
    190       precomp->source_layers().emplace_back(i->first);
    191   }
    192 
    193   return 0;
    194 }
    195 }
    196