#define LOG_TAG "hwc-drm-display-composition"
#include "drmdisplaycomposition.h"
+#include "drmdisplaycompositor.h"
#include "drmcrtc.h"
#include "drmplane.h"
#include "drmresources.h"
+#include "platform.h"
#include <stdlib.h>
-#include <cutils/log.h>
+#include <algorithm>
+#include <unordered_set>
+
+#include <log/log.h>
#include <sw_sync.h>
#include <sync/sync.h>
#include <xf86drmMode.h>
namespace android {
-DrmCompositionLayer::DrmCompositionLayer(DrmCrtc *crtc, DrmHwcLayer &&l)
- : crtc(crtc),
- sf_handle(l.sf_handle),
- buffer(std::move(l.buffer)),
- handle(std::move(l.handle)),
- transform(l.transform),
- blending(l.blending),
- alpha(l.alpha),
- source_crop(l.source_crop),
- display_frame(l.display_frame),
- source_damage(l.source_damage),
- acquire_fence(std::move(l.acquire_fence)) {
-}
-
-DrmDisplayComposition::DrmDisplayComposition()
- : drm_(NULL),
- importer_(NULL),
- type_(DRM_COMPOSITION_TYPE_EMPTY),
- timeline_fd_(-1),
- timeline_(0),
- timeline_current_(0),
- timeline_pre_comp_done_(0),
- pre_composition_layer_index_(-1),
- dpms_mode_(DRM_MODE_DPMS_ON),
- frame_no_(0) {
-}
-
DrmDisplayComposition::~DrmDisplayComposition() {
if (timeline_fd_ >= 0) {
- FinishComposition();
+ SignalCompositionDone();
close(timeline_fd_);
- timeline_fd_ = -1;
}
}
int DrmDisplayComposition::Init(DrmResources *drm, DrmCrtc *crtc,
- Importer *importer, uint64_t frame_no) {
+ Importer *importer, Planner *planner,
+ uint64_t frame_no) {
drm_ = drm;
crtc_ = crtc; // Can be NULL if we haven't modeset yet
importer_ = importer;
+ planner_ = planner;
frame_no_ = frame_no;
int ret = sw_sync_timeline_create();
return 0;
}
-DrmCompositionType DrmDisplayComposition::type() const {
- return type_;
-}
-
bool DrmDisplayComposition::validate_composition_type(DrmCompositionType des) {
return type_ == DRM_COMPOSITION_TYPE_EMPTY || type_ == des;
}
-static DrmPlane *TakePlane(DrmCrtc *crtc, std::vector<DrmPlane *> *planes) {
- for (auto iter = planes->begin(); iter != planes->end(); ++iter) {
- if ((*iter)->GetCrtcSupported(*crtc)) {
- DrmPlane *plane = *iter;
- planes->erase(iter);
- return plane;
- }
- }
- return NULL;
-}
-
-static DrmPlane *TakePlane(DrmCrtc *crtc,
- std::vector<DrmPlane *> *primary_planes,
- std::vector<DrmPlane *> *overlay_planes) {
- DrmPlane *plane = TakePlane(crtc, primary_planes);
- if (plane)
- return plane;
- return TakePlane(crtc, overlay_planes);
-}
-
int DrmDisplayComposition::CreateNextTimelineFence() {
++timeline_;
- return sw_sync_fence_create(timeline_fd_, "drm_fence", timeline_);
+ return sw_sync_fence_create(timeline_fd_, "hwc drm display composition fence",
+ timeline_);
}
int DrmDisplayComposition::IncreaseTimelineToPoint(int point) {
}
int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers,
- std::vector<DrmPlane *> *primary_planes,
- std::vector<DrmPlane *> *overlay_planes) {
- int ret = 0;
+ bool geometry_changed) {
if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
return -EINVAL;
- for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
- DrmHwcLayer *layer = &layers[layer_index];
-
- layers_.emplace_back(crtc_, std::move(*layer));
- DrmCompositionLayer *c_layer = &layers_.back();
-
- if (pre_composition_layer_index_ == -1) {
- c_layer->plane = TakePlane(crtc_, primary_planes, overlay_planes);
- if (c_layer->plane == NULL) {
- if (layers_.size() <= 1) {
- ALOGE("Failed to match any planes to the crtc of this display");
- ret = -ENODEV;
- goto fail;
- }
-
- layers_.emplace_back();
- // c_layer's address might have changed when we resized the vector
- c_layer = &layers_[layers_.size() - 2];
- DrmCompositionLayer &pre_comp_layer = layers_.back();
- pre_comp_layer.crtc = crtc_;
-
- pre_composition_layer_index_ = layers_.size() - 1;
-
- // This is all to fix up the previous layer, which has now become part
- // of the set of pre-composition layers because we are stealing its
- // plane.
- DrmCompositionLayer &last_c_layer = layers_[layers_.size() - 3];
- std::swap(pre_comp_layer.plane, last_c_layer.plane);
- OutputFd &last_release_fence = layers[layer_index - 1].release_fence;
- last_release_fence.Set(CreateNextTimelineFence());
- ret = last_release_fence.get();
- if (ret < 0) {
- ALOGE("Could not create release fence %d", ret);
- goto fail;
- }
- }
- }
-
- if (c_layer->plane == NULL) {
- // Layers to be pre composited all get the earliest release fences as they
- // will get released soonest.
- layer->release_fence.Set(CreateNextTimelineFence());
- ret = layer->release_fence.get();
- if (ret < 0) {
- ALOGE("Could not create release fence %d", ret);
- goto fail;
- }
- }
- }
-
- timeline_pre_comp_done_ = timeline_;
+ geometry_changed_ = geometry_changed;
for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
- DrmHwcLayer *layer = &layers[layer_index];
- if (layer->release_fence.get() >= 0)
- continue;
-
- ret = layer->release_fence.Set(CreateNextTimelineFence());
- if (ret < 0) {
- ALOGE("Could not create release fence %d", ret);
- goto fail;
- }
+ layers_.emplace_back(std::move(layers[layer_index]));
}
type_ = DRM_COMPOSITION_TYPE_FRAME;
return 0;
-
-fail:
-
- for (size_t c_layer_index = 0; c_layer_index < layers_.size();
- c_layer_index++) {
- DrmCompositionLayer &c_layer = layers_[c_layer_index];
- if (c_layer.plane != NULL) {
- std::vector<DrmPlane *> *return_to =
- (c_layer.plane->type() == DRM_PLANE_TYPE_PRIMARY) ? primary_planes
- : overlay_planes;
- return_to->insert(return_to->begin() + c_layer_index, c_layer.plane);
- }
- }
-
- layers_.clear();
-
- sw_sync_timeline_inc(timeline_fd_, timeline_ - timeline_current_);
-
- timeline_ = timeline_current_;
- return ret;
}
int DrmDisplayComposition::SetDpmsMode(uint32_t dpms_mode) {
}
int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
- layers_.emplace_back();
- DrmCompositionLayer &c_layer = layers_.back();
- c_layer.crtc = NULL;
- c_layer.plane = plane;
+ composition_planes_.emplace_back(DrmCompositionPlane::Type::kDisable, plane,
+ crtc_);
+ return 0;
+}
+
+static std::vector<size_t> SetBitsToVector(
+ uint64_t in, const std::vector<size_t> &index_map) {
+ std::vector<size_t> out;
+ size_t msb = sizeof(in) * 8 - 1;
+ uint64_t mask = (uint64_t)1 << msb;
+ for (size_t i = msb; mask != (uint64_t)0; i--, mask >>= 1)
+ if (in & mask)
+ out.push_back(index_map[i]);
+ return out;
+}
+
+int DrmDisplayComposition::AddPlaneComposition(DrmCompositionPlane plane) {
+ composition_planes_.emplace_back(std::move(plane));
+ return 0;
+}
+
+void DrmDisplayComposition::SeparateLayers(DrmHwcRect<int> *exclude_rects,
+ size_t num_exclude_rects) {
+ DrmCompositionPlane *comp = NULL;
+ std::vector<size_t> dedicated_layers;
+
+ // Go through the composition and find the precomp layer as well as any
+ // layers that have a dedicated plane located below the precomp layer.
+ for (auto &i : composition_planes_) {
+ if (i.type() == DrmCompositionPlane::Type::kLayer) {
+ dedicated_layers.insert(dedicated_layers.end(), i.source_layers().begin(),
+ i.source_layers().end());
+ } else if (i.type() == DrmCompositionPlane::Type::kPrecomp) {
+ comp = &i;
+ break;
+ }
+ }
+ if (!comp)
+ return;
+
+ const std::vector<size_t> &comp_layers = comp->source_layers();
+ if (comp_layers.size() > 64) {
+ ALOGE("Failed to separate layers because there are more than 64");
+ return;
+ }
+
+ // Index at which the actual layers begin
+ size_t layer_offset = num_exclude_rects + dedicated_layers.size();
+ if (comp_layers.size() + layer_offset > 64) {
+ ALOGW(
+ "Exclusion rectangles are being truncated to make the rectangle count "
+ "fit into 64");
+ num_exclude_rects = 64 - comp_layers.size() - dedicated_layers.size();
+ }
+
+ // We inject all the exclude rects into the rects list. Any resulting rect
+ // that includes ANY of the first num_exclude_rects is rejected. After the
+ // exclude rects, we add the lower layers. The rects that intersect with
+ // these layers will be inspected and only those which are to be composited
+ // above the layer will be included in the composition regions.
+ std::vector<DrmHwcRect<int>> layer_rects(comp_layers.size() + layer_offset);
+ std::copy(exclude_rects, exclude_rects + num_exclude_rects,
+ layer_rects.begin());
+ std::transform(
+ dedicated_layers.begin(), dedicated_layers.end(),
+ layer_rects.begin() + num_exclude_rects,
+ [=](size_t layer_index) { return layers_[layer_index].display_frame; });
+ std::transform(comp_layers.begin(), comp_layers.end(),
+ layer_rects.begin() + layer_offset, [=](size_t layer_index) {
+ return layers_[layer_index].display_frame;
+ });
+
+ std::vector<separate_rects::RectSet<uint64_t, int>> separate_regions;
+ separate_rects::separate_rects_64(layer_rects, &separate_regions);
+ uint64_t exclude_mask = ((uint64_t)1 << num_exclude_rects) - 1;
+ uint64_t dedicated_mask = (((uint64_t)1 << dedicated_layers.size()) - 1)
+ << num_exclude_rects;
+
+ for (separate_rects::RectSet<uint64_t, int> ®ion : separate_regions) {
+ if (region.id_set.getBits() & exclude_mask)
+ continue;
+
+ // If a rect intersects one of the dedicated layers, we need to remove the
+ // layers from the composition region which appear *below* the dedicated
+ // layer. This effectively punches a hole through the composition layer such
+ // that the dedicated layer can be placed below the composition and not
+ // be occluded.
+ uint64_t dedicated_intersect = region.id_set.getBits() & dedicated_mask;
+ for (size_t i = 0; dedicated_intersect && i < dedicated_layers.size();
+ ++i) {
+ // Only exclude layers if they intersect this particular dedicated layer
+ if (!(dedicated_intersect & (1 << (i + num_exclude_rects))))
+ continue;
+
+ for (size_t j = 0; j < comp_layers.size(); ++j) {
+ if (comp_layers[j] < dedicated_layers[i])
+ region.id_set.subtract(j + layer_offset);
+ }
+ }
+ if (!(region.id_set.getBits() >> layer_offset))
+ continue;
+
+ pre_comp_regions_.emplace_back(DrmCompositionRegion{
+ region.rect,
+ SetBitsToVector(region.id_set.getBits() >> layer_offset, comp_layers)});
+ }
+}
+
+int DrmDisplayComposition::CreateAndAssignReleaseFences() {
+ std::unordered_set<DrmHwcLayer *> squash_layers;
+ std::unordered_set<DrmHwcLayer *> pre_comp_layers;
+ std::unordered_set<DrmHwcLayer *> comp_layers;
+
+ for (const DrmCompositionRegion ®ion : squash_regions_) {
+ for (size_t source_layer_index : region.source_layers) {
+ DrmHwcLayer *source_layer = &layers_[source_layer_index];
+ squash_layers.emplace(source_layer);
+ }
+ }
+
+ for (const DrmCompositionRegion ®ion : pre_comp_regions_) {
+ for (size_t source_layer_index : region.source_layers) {
+ DrmHwcLayer *source_layer = &layers_[source_layer_index];
+ pre_comp_layers.emplace(source_layer);
+ squash_layers.erase(source_layer);
+ }
+ }
+
+ for (const DrmCompositionPlane &plane : composition_planes_) {
+ if (plane.type() == DrmCompositionPlane::Type::kLayer) {
+ for (auto i : plane.source_layers()) {
+ DrmHwcLayer *source_layer = &layers_[i];
+ comp_layers.emplace(source_layer);
+ pre_comp_layers.erase(source_layer);
+ }
+ }
+ }
+
+ for (DrmHwcLayer *layer : squash_layers) {
+ if (!layer->release_fence)
+ continue;
+ int ret = layer->release_fence.Set(CreateNextTimelineFence());
+ if (ret < 0) {
+ ALOGE("Failed to set the release fence (squash) %d", ret);
+ return ret;
+ }
+ }
+ timeline_squash_done_ = timeline_;
+
+ for (DrmHwcLayer *layer : pre_comp_layers) {
+ if (!layer->release_fence)
+ continue;
+ int ret = layer->release_fence.Set(CreateNextTimelineFence());
+ if (ret < 0)
+ return ret;
+ }
+ timeline_pre_comp_done_ = timeline_;
+
+ for (DrmHwcLayer *layer : comp_layers) {
+ if (!layer->release_fence)
+ continue;
+ int ret = layer->release_fence.Set(CreateNextTimelineFence());
+ if (ret < 0) {
+ ALOGE("Failed to set the release fence (comp) %d", ret);
+ return ret;
+ }
+ }
+
return 0;
}
-void DrmDisplayComposition::RemoveNoPlaneLayers() {
- layers_.erase(
- std::remove_if(layers_.begin(), layers_.end(),
- [](DrmCompositionLayer &l) { return l.plane == NULL; }),
- layers_.end());
+int DrmDisplayComposition::Plan(SquashState *squash,
+ std::vector<DrmPlane *> *primary_planes,
+ std::vector<DrmPlane *> *overlay_planes) {
+ if (type_ != DRM_COMPOSITION_TYPE_FRAME)
+ return 0;
+
+ // Used to track which layers should be sent to the planner. We exclude layers
+ // that are entirely squashed so the planner can provision a precomposition
+ // layer as appropriate (ex: if 5 layers are squashed and 1 is not, we don't
+ // want to plan a precomposition layer that will be comprised of the already
+ // squashed layers).
+ std::map<size_t, DrmHwcLayer *> to_composite;
+
+ bool use_squash_framebuffer = false;
+ // Used to determine which layers were entirely squashed
+ std::vector<int> layer_squash_area(layers_.size(), 0);
+ // Used to avoid rerendering regions that were squashed
+ std::vector<DrmHwcRect<int>> exclude_rects;
+ if (squash != NULL) {
+ if (geometry_changed_) {
+ squash->Init(layers_.data(), layers_.size());
+ } else {
+ std::vector<bool> changed_regions;
+ squash->GenerateHistory(layers_.data(), layers_.size(), changed_regions);
+
+ std::vector<bool> stable_regions;
+ squash->StableRegionsWithMarginalHistory(changed_regions, stable_regions);
+
+ // Only if SOME region is stable
+ use_squash_framebuffer =
+ std::find(stable_regions.begin(), stable_regions.end(), true) !=
+ stable_regions.end();
+
+ squash->RecordHistory(layers_.data(), layers_.size(), changed_regions);
+
+ // Changes in which regions are squashed triggers a rerender via
+ // squash_regions.
+ bool render_squash = squash->RecordAndCompareSquashed(stable_regions);
+
+ for (size_t region_index = 0; region_index < stable_regions.size();
+ region_index++) {
+ const SquashState::Region ®ion = squash->regions()[region_index];
+ if (!stable_regions[region_index])
+ continue;
+
+ exclude_rects.emplace_back(region.rect);
+
+ if (render_squash) {
+ squash_regions_.emplace_back();
+ squash_regions_.back().frame = region.rect;
+ }
+
+ int frame_area = region.rect.area();
+ // Source layers are sorted front to back i.e. top layer has lowest
+ // index.
+ for (size_t layer_index = layers_.size();
+ layer_index-- > 0; // Yes, I double checked this
+ /* See condition */) {
+ if (!region.layer_refs[layer_index])
+ continue;
+ layer_squash_area[layer_index] += frame_area;
+ if (render_squash)
+ squash_regions_.back().source_layers.push_back(layer_index);
+ }
+ }
+ }
+
+ for (size_t i = 0; i < layers_.size(); ++i) {
+ if (layer_squash_area[i] < layers_[i].display_frame.area())
+ to_composite.emplace(std::make_pair(i, &layers_[i]));
+ }
+ } else {
+ for (size_t i = 0; i < layers_.size(); ++i)
+ to_composite.emplace(std::make_pair(i, &layers_[i]));
+ }
+
+ int ret;
+ std::vector<DrmCompositionPlane> plan;
+ std::tie(ret, composition_planes_) =
+ planner_->ProvisionPlanes(to_composite, use_squash_framebuffer, crtc_,
+ primary_planes, overlay_planes);
+ if (ret) {
+ ALOGE("Planner failed provisioning planes ret=%d", ret);
+ return ret;
+ }
+
+ // Remove the planes we used from the pool before returning. This ensures they
+ // won't be reused by another display in the composition.
+ for (auto &i : composition_planes_) {
+ if (!i.plane())
+ continue;
+
+ // make sure that source layers are ordered based on zorder
+ std::sort(i.source_layers().begin(), i.source_layers().end());
+
+ std::vector<DrmPlane *> *container;
+ if (i.plane()->type() == DRM_PLANE_TYPE_PRIMARY)
+ container = primary_planes;
+ else
+ container = overlay_planes;
+ for (auto j = container->begin(); j != container->end(); ++j) {
+ if (*j == i.plane()) {
+ container->erase(j);
+ break;
+ }
+ }
+ }
+
+ return FinalizeComposition(exclude_rects.data(), exclude_rects.size());
}
-int DrmDisplayComposition::SignalPreCompositionDone() {
- return IncreaseTimelineToPoint(timeline_pre_comp_done_);
+int DrmDisplayComposition::FinalizeComposition() {
+ return FinalizeComposition(NULL, 0);
}
-int DrmDisplayComposition::FinishComposition() {
- return IncreaseTimelineToPoint(timeline_);
+int DrmDisplayComposition::FinalizeComposition(DrmHwcRect<int> *exclude_rects,
+ size_t num_exclude_rects) {
+ SeparateLayers(exclude_rects, num_exclude_rects);
+ return CreateAndAssignReleaseFences();
}
-std::vector<DrmCompositionLayer>
- *DrmDisplayComposition::GetCompositionLayers() {
- return &layers_;
+static const char *DrmCompositionTypeToString(DrmCompositionType type) {
+ switch (type) {
+ case DRM_COMPOSITION_TYPE_EMPTY:
+ return "EMPTY";
+ case DRM_COMPOSITION_TYPE_FRAME:
+ return "FRAME";
+ case DRM_COMPOSITION_TYPE_DPMS:
+ return "DPMS";
+ case DRM_COMPOSITION_TYPE_MODESET:
+ return "MODESET";
+ default:
+ return "<invalid>";
+ }
}
-int DrmDisplayComposition::pre_composition_layer_index() const {
- return pre_composition_layer_index_;
+static const char *DPMSModeToString(int dpms_mode) {
+ switch (dpms_mode) {
+ case DRM_MODE_DPMS_ON:
+ return "ON";
+ case DRM_MODE_DPMS_OFF:
+ return "OFF";
+ default:
+ return "<invalid>";
+ }
+}
+
+static void DumpBuffer(const DrmHwcBuffer &buffer, std::ostringstream *out) {
+ if (!buffer) {
+ *out << "buffer=<invalid>";
+ return;
+ }
+
+ *out << "buffer[w/h/format]=";
+ *out << buffer->width << "/" << buffer->height << "/" << buffer->format;
}
-uint32_t DrmDisplayComposition::dpms_mode() const {
- return dpms_mode_;
+static void DumpTransform(uint32_t transform, std::ostringstream *out) {
+ *out << "[";
+
+ if (transform == 0)
+ *out << "IDENTITY";
+
+ bool separator = false;
+ if (transform & DrmHwcTransform::kFlipH) {
+ *out << "FLIPH";
+ separator = true;
+ }
+ if (transform & DrmHwcTransform::kFlipV) {
+ if (separator)
+ *out << "|";
+ *out << "FLIPV";
+ separator = true;
+ }
+ if (transform & DrmHwcTransform::kRotate90) {
+ if (separator)
+ *out << "|";
+ *out << "ROTATE90";
+ separator = true;
+ }
+ if (transform & DrmHwcTransform::kRotate180) {
+ if (separator)
+ *out << "|";
+ *out << "ROTATE180";
+ separator = true;
+ }
+ if (transform & DrmHwcTransform::kRotate270) {
+ if (separator)
+ *out << "|";
+ *out << "ROTATE270";
+ separator = true;
+ }
+
+ uint32_t valid_bits = DrmHwcTransform::kFlipH | DrmHwcTransform::kFlipH |
+ DrmHwcTransform::kRotate90 |
+ DrmHwcTransform::kRotate180 |
+ DrmHwcTransform::kRotate270;
+ if (transform & ~valid_bits) {
+ if (separator)
+ *out << "|";
+ *out << "INVALID";
+ }
+ *out << "]";
}
-uint64_t DrmDisplayComposition::frame_no() const {
- return frame_no_;
+static const char *BlendingToString(DrmHwcBlending blending) {
+ switch (blending) {
+ case DrmHwcBlending::kNone:
+ return "NONE";
+ case DrmHwcBlending::kPreMult:
+ return "PREMULT";
+ case DrmHwcBlending::kCoverage:
+ return "COVERAGE";
+ default:
+ return "<invalid>";
+ }
}
-const DrmMode &DrmDisplayComposition::display_mode() const {
- return display_mode_;
+static void DumpRegion(const DrmCompositionRegion ®ion,
+ std::ostringstream *out) {
+ *out << "frame";
+ region.frame.Dump(out);
+ *out << " source_layers=(";
+
+ const std::vector<size_t> &source_layers = region.source_layers;
+ for (size_t i = 0; i < source_layers.size(); i++) {
+ *out << source_layers[i];
+ if (i < source_layers.size() - 1) {
+ *out << " ";
+ }
+ }
+
+ *out << ")";
}
-Importer *DrmDisplayComposition::importer() const {
- return importer_;
+void DrmDisplayComposition::Dump(std::ostringstream *out) const {
+ *out << "----DrmDisplayComposition"
+ << " crtc=" << (crtc_ ? crtc_->id() : -1)
+ << " type=" << DrmCompositionTypeToString(type_);
+
+ switch (type_) {
+ case DRM_COMPOSITION_TYPE_DPMS:
+ *out << " dpms_mode=" << DPMSModeToString(dpms_mode_);
+ break;
+ case DRM_COMPOSITION_TYPE_MODESET:
+ *out << " display_mode=" << display_mode_.h_display() << "x"
+ << display_mode_.v_display();
+ break;
+ default:
+ break;
+ }
+
+ *out << " timeline[current/squash/pre-comp/done]=" << timeline_current_ << "/"
+ << timeline_squash_done_ << "/" << timeline_pre_comp_done_ << "/"
+ << timeline_ << "\n";
+
+ *out << " Layers: count=" << layers_.size() << "\n";
+ for (size_t i = 0; i < layers_.size(); i++) {
+ const DrmHwcLayer &layer = layers_[i];
+ *out << " [" << i << "] ";
+
+ DumpBuffer(layer.buffer, out);
+
+ if (layer.protected_usage())
+ *out << " protected";
+
+ *out << " transform=";
+ DumpTransform(layer.transform, out);
+ *out << " blending[a=" << (int)layer.alpha
+ << "]=" << BlendingToString(layer.blending) << " source_crop";
+ layer.source_crop.Dump(out);
+ *out << " display_frame";
+ layer.display_frame.Dump(out);
+
+ *out << "\n";
+ }
+
+ *out << " Planes: count=" << composition_planes_.size() << "\n";
+ for (size_t i = 0; i < composition_planes_.size(); i++) {
+ const DrmCompositionPlane &comp_plane = composition_planes_[i];
+ *out << " [" << i << "]"
+ << " plane=" << (comp_plane.plane() ? comp_plane.plane()->id() : -1)
+ << " type=";
+ switch (comp_plane.type()) {
+ case DrmCompositionPlane::Type::kDisable:
+ *out << "DISABLE";
+ break;
+ case DrmCompositionPlane::Type::kLayer:
+ *out << "LAYER";
+ break;
+ case DrmCompositionPlane::Type::kPrecomp:
+ *out << "PRECOMP";
+ break;
+ case DrmCompositionPlane::Type::kSquash:
+ *out << "SQUASH";
+ break;
+ default:
+ *out << "<invalid>";
+ break;
+ }
+
+ *out << " source_layer=";
+ for (auto i : comp_plane.source_layers()) {
+ *out << i << " ";
+ }
+ *out << "\n";
+ }
+
+ *out << " Squash Regions: count=" << squash_regions_.size() << "\n";
+ for (size_t i = 0; i < squash_regions_.size(); i++) {
+ *out << " [" << i << "] ";
+ DumpRegion(squash_regions_[i], out);
+ *out << "\n";
+ }
+
+ *out << " Pre-Comp Regions: count=" << pre_comp_regions_.size() << "\n";
+ for (size_t i = 0; i < pre_comp_regions_.size(); i++) {
+ *out << " [" << i << "] ";
+ DumpRegion(pre_comp_regions_[i], out);
+ *out << "\n";
+ }
}
}