#include <stdlib.h>
+#include <algorithm>
+#include <unordered_set>
+
#include <cutils/log.h>
#include <sw_sync.h>
#include <sync/sync.h>
namespace android {
-static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
- native_handle_t *new_handle =
- native_handle_create(handle->numFds, handle->numInts);
- if (new_handle == NULL)
- return NULL;
-
- const int *old_data = handle->data;
- int *new_data = new_handle->data;
- for (int i = 0; i < handle->numFds; i++) {
- *new_data = dup(*old_data);
- old_data++;
- new_data++;
- }
- memcpy(new_data, old_data, sizeof(int) * handle->numInts);
-
- return new_handle;
-}
-
-static void free_buffer_handle(native_handle_t *handle) {
- int ret = native_handle_close(handle);
- if (ret)
- ALOGE("Failed to close native handle %d", ret);
- ret = native_handle_delete(handle);
- if (ret)
- ALOGE("Failed to delete native handle %d", ret);
-}
-
-DrmCompositionLayer::DrmCompositionLayer()
- : crtc(NULL), plane(NULL), handle(NULL) {
- memset(&layer, 0, sizeof(layer));
- layer.releaseFenceFd = -1;
- layer.acquireFenceFd = -1;
- memset(&bo, 0, sizeof(bo));
-}
-
-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) {
-}
+const size_t DrmCompositionPlane::kSourceNone;
+const size_t DrmCompositionPlane::kSourcePreComp;
+const size_t DrmCompositionPlane::kSourceSquash;
+const size_t DrmCompositionPlane::kSourceLayerMax;
DrmDisplayComposition::~DrmDisplayComposition() {
- for (DrmCompositionLayerVector_t::iterator iter = layers_.begin();
- iter != layers_.end(); ++iter) {
- if (importer_ && iter->bo.fb_id)
- importer_->ReleaseBuffer(&iter->bo);
-
- if (iter->handle) {
- gralloc_->unregisterBuffer(gralloc_, iter->handle);
- free_buffer_handle(iter->handle);
- }
-
- if (iter->layer.acquireFenceFd >= 0)
- close(iter->layer.acquireFenceFd);
- }
-
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) {
drm_ = drm;
- crtc_ = crtc; // Can be NULL if we haven't modeset yet
+ crtc_ = crtc; // Can be NULL if we haven't modeset yet
importer_ = importer;
frame_no_ = frame_no;
- int ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
- (const hw_module_t **)&gralloc_);
- if (ret) {
- ALOGE("Failed to open gralloc module %d", ret);
- return ret;
- }
-
- ret = sw_sync_timeline_create();
+ int ret = sw_sync_timeline_create();
if (ret < 0) {
ALOGE("Failed to create sw sync timeline %d", ret);
return ret;
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) {
return ret;
}
-int DrmDisplayComposition::SetLayers(hwc_layer_1_t *layers, size_t num_layers,
- size_t *layer_indices,
- std::vector<DrmPlane *> *primary_planes,
- std::vector<DrmPlane *> *overlay_planes) {
+int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers) {
int ret = 0;
if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
return -EINVAL;
for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
- hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
-
- native_handle_t *handle_copy = dup_buffer_handle(layer->handle);
- if (handle_copy == NULL) {
- ALOGE("Failed to duplicate handle");
- return -ENOMEM;
- }
+ layers_.emplace_back(std::move(layers[layer_index]));
+ }
- int ret = gralloc_->registerBuffer(gralloc_, handle_copy);
- if (ret) {
- ALOGE("Failed to register buffer handle %d", ret);
- free_buffer_handle(handle_copy);
- return ret;
- }
+ type_ = DRM_COMPOSITION_TYPE_FRAME;
+ return 0;
+}
- layers_.emplace_back();
- DrmCompositionLayer_t *c_layer = &layers_.back();
- c_layer->layer = *layer;
- c_layer->handle = handle_copy;
- c_layer->crtc = crtc_;
+int DrmDisplayComposition::SetDpmsMode(uint32_t dpms_mode) {
+ if (!validate_composition_type(DRM_COMPOSITION_TYPE_DPMS))
+ return -EINVAL;
+ dpms_mode_ = dpms_mode;
+ type_ = DRM_COMPOSITION_TYPE_DPMS;
+ return 0;
+}
- ret = importer_->ImportBuffer(layer->handle, &c_layer->bo);
- if (ret) {
- ALOGE("Failed to import handle of layer %d", ret);
- goto fail;
- }
+int DrmDisplayComposition::SetDisplayMode(const DrmMode &display_mode) {
+ if (!validate_composition_type(DRM_COMPOSITION_TYPE_MODESET))
+ return -EINVAL;
+ display_mode_ = display_mode;
+ dpms_mode_ = DRM_MODE_DPMS_ON;
+ type_ = DRM_COMPOSITION_TYPE_MODESET;
+ return 0;
+}
- 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;
- }
+int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
+ composition_planes_.emplace_back(
+ DrmCompositionPlane{plane, crtc_, DrmCompositionPlane::kSourceNone});
+ return 0;
+}
- layers_.emplace_back();
- // c_layer's address might have changed when we resized the vector
- c_layer = &layers_[layers_.size() - 2];
- DrmCompositionLayer_t &pre_comp_layer = layers_.back();
- pre_comp_layer.crtc = crtc_;
- hwc_layer_1_t &pre_comp_output_layer = pre_comp_layer.layer;
- memset(&pre_comp_output_layer, 0, sizeof(pre_comp_output_layer));
- pre_comp_output_layer.compositionType = HWC_OVERLAY;
- pre_comp_output_layer.acquireFenceFd = -1;
- pre_comp_output_layer.releaseFenceFd = -1;
- pre_comp_output_layer.planeAlpha = 0xff;
- pre_comp_output_layer.visibleRegionScreen.numRects = 1;
- pre_comp_output_layer.visibleRegionScreen.rects =
- &pre_comp_output_layer.displayFrame;
-
- 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_t &last_c_layer = layers_[layers_.size() - 3];
- std::swap(pre_comp_layer.plane, last_c_layer.plane);
- hwc_layer_1_t *last_layer = &layers[layer_indices[layer_index - 1]];
- ret = last_layer->releaseFenceFd = CreateNextTimelineFence();
- if (ret < 0) {
- ALOGE("Could not create release fence %d", ret);
- goto fail;
- }
- }
- }
+static size_t CountUsablePlanes(DrmCrtc *crtc,
+ std::vector<DrmPlane *> *primary_planes,
+ std::vector<DrmPlane *> *overlay_planes) {
+ return std::count_if(
+ primary_planes->begin(), primary_planes->end(),
+ [=](DrmPlane *plane) { return plane->GetCrtcSupported(*crtc); }) +
+ std::count_if(
+ overlay_planes->begin(), overlay_planes->end(),
+ [=](DrmPlane *plane) { return plane->GetCrtcSupported(*crtc); });
+}
- if (c_layer->plane == NULL) {
- // Layers to be pre composited all get the earliest release fences as they
- // will get released soonest.
- ret = layer->releaseFenceFd = CreateNextTimelineFence();
- if (ret < 0) {
- ALOGE("Could not create release fence %d", ret);
- goto fail;
- }
+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;
+}
- timeline_pre_comp_done_ = timeline_;
+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);
+}
- for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
- hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
- if (layer->releaseFenceFd >= 0)
- continue;
+static std::vector<size_t> SetBitsToVector(uint64_t in, 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;
+}
- ret = layer->releaseFenceFd = CreateNextTimelineFence();
- if (ret < 0) {
- ALOGE("Could not create release fence %d", ret);
- goto fail;
- }
+static void SeperateLayers(DrmHwcLayer *layers, size_t *used_layers,
+ size_t num_used_layers,
+ DrmHwcRect<int> *exclude_rects,
+ size_t num_exclude_rects,
+ std::vector<DrmCompositionRegion> ®ions) {
+ if (num_used_layers > 64) {
+ ALOGE("Failed to separate layers because there are more than 64");
+ return;
}
- for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
- hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
- layer->acquireFenceFd = -1; // We own this now
+ if (num_used_layers + num_exclude_rects > 64) {
+ ALOGW(
+ "Exclusion rectangles are being truncated to make the rectangle count "
+ "fit into 64");
+ num_exclude_rects = 64 - num_used_layers;
}
- type_ = DRM_COMPOSITION_TYPE_FRAME;
- return 0;
+ // We inject all the exclude rects into the rects list. Any resulting rect
+ // that includes ANY of the first num_exclude_rects is rejected.
+ std::vector<DrmHwcRect<int>> layer_rects(num_used_layers + num_exclude_rects);
+ std::copy(exclude_rects, exclude_rects + num_exclude_rects,
+ layer_rects.begin());
+ std::transform(
+ used_layers, used_layers + num_used_layers,
+ layer_rects.begin() + num_exclude_rects,
+ [=](size_t layer_index) { return layers[layer_index].display_frame; });
+
+ std::vector<seperate_rects::RectSet<uint64_t, int>> seperate_regions;
+ seperate_rects::seperate_rects_64(layer_rects, &seperate_regions);
+ uint64_t exclude_mask = ((uint64_t)1 << num_exclude_rects) - 1;
+
+ for (seperate_rects::RectSet<uint64_t, int> ®ion : seperate_regions) {
+ if (region.id_set.getBits() & exclude_mask)
+ continue;
+ regions.emplace_back(DrmCompositionRegion{
+ region.rect,
+ SetBitsToVector(region.id_set.getBits() >> num_exclude_rects,
+ used_layers)});
+ }
+}
-fail:
+int DrmDisplayComposition::Plan(SquashState *squash,
+ std::vector<DrmPlane *> *primary_planes,
+ std::vector<DrmPlane *> *overlay_planes) {
+ size_t planes_can_use =
+ CountUsablePlanes(crtc_, primary_planes, overlay_planes);
+ if (planes_can_use == 0) {
+ ALOGE("Display %d has no usable planes", crtc_->display());
+ return -ENODEV;
+ }
- for (size_t c_layer_index = 0; c_layer_index < layers_.size();
- c_layer_index++) {
- DrmCompositionLayer_t &c_layer = layers_[c_layer_index];
- if (c_layer.handle) {
- gralloc_->unregisterBuffer(gralloc_, c_layer.handle);
- free_buffer_handle(c_layer.handle);
- }
- if (c_layer.bo.fb_id)
- importer_->ReleaseBuffer(&c_layer.bo);
- 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);
+ std::vector<int> layer_squash_area(layers_.size());
+ if (squash != NULL && planes_can_use >= 3) {
+ std::vector<bool> changed_regions;
+ squash->GenerateHistory(layers_.data(), changed_regions);
+
+ std::vector<bool> stable_regions;
+ squash->StableRegionsWithMarginalHistory(changed_regions, stable_regions);
+
+ squash->RecordHistory(layers_.data(), changed_regions);
+
+ squash->RecordSquashed(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]) {
+ squash_regions_.emplace_back();
+ DrmCompositionRegion &squash_region = squash_regions_.back();
+ squash_region.frame = region.rect;
+ for (size_t layer_index = 0; layer_index < SquashState::kMaxLayers;
+ layer_index++) {
+ if (region.layer_refs[layer_index]) {
+ squash_region.source_layers.push_back(layer_index);
+ layer_squash_area[layer_index] += squash_region.frame.area();
+ }
+ }
+ }
}
}
- layers_.clear();
- for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
- hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
- if (layer->releaseFenceFd >= 0) {
- close(layer->releaseFenceFd);
- layer->releaseFenceFd = -1;
+ std::vector<size_t> layers_remaining;
+ for (size_t layer_index = 0; layer_index < layers_.size(); layer_index++) {
+ // Skip layers that were completely squashed
+ if (layer_squash_area[layer_index] >=
+ layers_[layer_index].display_frame.area()) {
+ continue;
}
+
+ layers_remaining.push_back(layer_index);
}
- sw_sync_timeline_inc(timeline_fd_, timeline_ - timeline_current_);
- timeline_ = timeline_current_;
- return ret;
-}
+ size_t layer_to_composite = layers_remaining.size();
+ size_t num_layers_to_pre_composite = 0;
+ if (squash_regions_.size() > 0) {
+ layers_remaining.push_back(DrmCompositionPlane::kSourceSquash);
+ }
-int DrmDisplayComposition::SetDpmsMode(uint32_t dpms_mode) {
- if (!validate_composition_type(DRM_COMPOSITION_TYPE_DPMS))
- return -EINVAL;
- dpms_mode_ = dpms_mode;
- type_ = DRM_COMPOSITION_TYPE_DPMS;
- return 0;
-}
+ if (layers_remaining.size() > planes_can_use) {
+ layers_remaining.insert(layers_remaining.begin() + layer_to_composite,
+ DrmCompositionPlane::kSourcePreComp);
+ size_t num_layers_to_pre_composite =
+ layer_to_composite - planes_can_use + 1;
+ size_t first_layer_to_pre_composite = planes_can_use - 1;
+ SeperateLayers(layers_.data(),
+ &layers_remaining[first_layer_to_pre_composite],
+ num_layers_to_pre_composite, NULL, 0, pre_comp_regions_);
+ layers_remaining.erase(
+ layers_remaining.begin() + first_layer_to_pre_composite,
+ layers_remaining.begin() + layer_to_composite);
+ }
-int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
- layers_.emplace_back();
- DrmCompositionLayer_t &c_layer = layers_.back();
- c_layer.crtc = NULL;
- c_layer.plane = plane;
- return 0;
-}
+ for (size_t i : layers_remaining) {
+ composition_planes_.emplace_back(DrmCompositionPlane{
+ TakePlane(crtc_, primary_planes, overlay_planes), crtc_, i});
+ }
-void DrmDisplayComposition::RemoveNoPlaneLayers() {
- for (auto &comp_layer : layers_) {
- if (comp_layer.plane != NULL)
- continue;
+ std::unordered_set<DrmHwcLayer *> squash_layers;
+ std::unordered_set<DrmHwcLayer *> pre_comp_layers;
+ std::unordered_set<DrmHwcLayer *> comp_layers;
- if (importer_ && comp_layer.bo.fb_id) {
- importer_->ReleaseBuffer(&comp_layer.bo);
+ 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);
}
+ }
- if (comp_layer.handle) {
- gralloc_->unregisterBuffer(gralloc_, comp_layer.handle);
- free_buffer_handle(comp_layer.handle);
+ 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);
}
+ }
- if (comp_layer.layer.acquireFenceFd >= 0) {
- close(comp_layer.layer.acquireFenceFd);
- comp_layer.layer.acquireFenceFd = -1;
+ for (const DrmCompositionPlane &plane : composition_planes_) {
+ if (plane.source_layer <= DrmCompositionPlane::kSourceLayerMax) {
+ DrmHwcLayer *source_layer = &layers_[plane.source_layer];
+ comp_layers.emplace(source_layer);
+ pre_comp_layers.erase(source_layer);
}
}
- layers_.erase(
- std::remove_if(layers_.begin(), layers_.end(),
- [](DrmCompositionLayer_t &l) { return l.plane == NULL; }),
- layers_.end());
-}
-
-int DrmDisplayComposition::SignalPreCompositionDone() {
- return IncreaseTimelineToPoint(timeline_pre_comp_done_);
-}
-
-int DrmDisplayComposition::FinishComposition() {
- return IncreaseTimelineToPoint(timeline_);
-}
-
-DrmCompositionLayerVector_t *DrmDisplayComposition::GetCompositionLayers() {
- return &layers_;
-}
-
-int DrmDisplayComposition::pre_composition_layer_index() const {
- return pre_composition_layer_index_;
-}
+ for (DrmHwcLayer *layer : squash_layers) {
+ int ret = layer->release_fence.Set(CreateNextTimelineFence());
+ if (ret < 0)
+ return ret;
+ }
+ timeline_squash_done_ = timeline_;
-uint32_t DrmDisplayComposition::dpms_mode() const {
- return dpms_mode_;
-}
+ for (DrmHwcLayer *layer : pre_comp_layers) {
+ int ret = layer->release_fence.Set(CreateNextTimelineFence());
+ if (ret < 0)
+ return ret;
+ }
+ timeline_pre_comp_done_ = timeline_;
-uint64_t DrmDisplayComposition::frame_no() const {
- return frame_no_;
-}
+ for (DrmHwcLayer *layer : comp_layers) {
+ int ret = layer->release_fence.Set(CreateNextTimelineFence());
+ if (ret < 0)
+ return ret;
+ }
-Importer *DrmDisplayComposition::importer() const {
- return importer_;
+ return 0;
}
}