drm_hwcomposer: Remove hwc.drm.use_framebuffer_target property

[android-x86/external-drm_hwcomposer.git] / drmcomposition.cpp

diff --git a/drmcomposition.cpp b/drmcomposition.cpp
index 805fd26..09bdba7 100644 (file)
--- a/drmcomposition.cpp
+++ b/drmcomposition.cpp
@@ -24,28 +24,28 @@
 #include <stdlib.h>
 
 #include <cutils/log.h>
+#include <cutils/properties.h>
 #include <sw_sync.h>
 #include <sync/sync.h>
 
 namespace android {
 
-static const bool kUseOverlayPlanes = true;
-
 DrmComposition::DrmComposition(DrmResources *drm, Importer *importer)
     : drm_(drm), importer_(importer) {
+  char use_overlay_planes_prop[PROPERTY_VALUE_MAX];
+  property_get("hwc.drm.use_overlay_planes", use_overlay_planes_prop, "1");
+  bool use_overlay_planes = atoi(use_overlay_planes_prop);
+
   for (DrmResources::PlaneIter iter = drm_->begin_planes();
        iter != drm_->end_planes(); ++iter) {
     if ((*iter)->type() == DRM_PLANE_TYPE_PRIMARY)
       primary_planes_.push_back(*iter);
-    else if (kUseOverlayPlanes && (*iter)->type() == DRM_PLANE_TYPE_OVERLAY)
+    else if (use_overlay_planes && (*iter)->type() == DRM_PLANE_TYPE_OVERLAY)
       overlay_planes_.push_back(*iter);
   }
 }
 
-DrmComposition::~DrmComposition() {
-}
-
-int DrmComposition::Init() {
+int DrmComposition::Init(uint64_t frame_no) {
   for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
        iter != drm_->end_connectors(); ++iter) {
     int display = (*iter)->display();
@@ -54,72 +54,47 @@ int DrmComposition::Init() {
       ALOGE("Failed to allocate new display composition\n");
       return -ENOMEM;
     }
-    int ret = composition_map_[(*iter)->display()]->Init(drm_, importer_);
+
+    // If the display hasn't been modeset yet, this will be NULL
+    DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);
+
+    int ret = composition_map_[display]->Init(drm_, crtc, importer_, frame_no);
     if (ret) {
-      ALOGE("Failed to init display composition for %d", (*iter)->display());
+      ALOGE("Failed to init display composition for %d", display);
       return ret;
     }
   }
   return 0;
 }
 
-unsigned DrmComposition::GetRemainingLayers(int display,
-                                            unsigned num_needed) const {
-  DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);
-  if (!crtc) {
-    ALOGE("Failed to find crtc for display %d", display);
-    return 0;
-  }
+int DrmComposition::SetLayers(size_t num_displays,
+                              DrmCompositionDisplayLayersMap *maps) {
+  int ret = 0;
+  for (size_t display_index = 0; display_index < num_displays;
+       display_index++) {
+    DrmCompositionDisplayLayersMap &map = maps[display_index];
+    int display = map.display;
 
-  unsigned num_planes = 0;
-  for (std::vector<DrmPlane *>::const_iterator iter = primary_planes_.begin();
-       iter != primary_planes_.end(); ++iter) {
-    if ((*iter)->GetCrtcSupported(*crtc))
-      ++num_planes;
-  }
-  for (std::vector<DrmPlane *>::const_iterator iter = overlay_planes_.begin();
-       iter != overlay_planes_.end(); ++iter) {
-    if ((*iter)->GetCrtcSupported(*crtc))
-      ++num_planes;
-  }
-  return std::min(num_planes, num_needed);
-}
+    if (!drm_->GetConnectorForDisplay(display)) {
+      ALOGE("Invalid display given to SetLayers %d", display);
+      continue;
+    }
 
-int DrmComposition::AddLayer(int display, hwc_layer_1_t *layer,
-                             hwc_drm_bo *bo) {
-  DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);
-  if (!crtc) {
-    ALOGE("Failed to find crtc for display %d", display);
-    return -ENODEV;
+    ret = composition_map_[display]->SetLayers(map.layers.data(),
+                                               map.layers.size());
+    if (ret)
+      return ret;
   }
 
-  // Find a plane for the layer
-  DrmPlane *plane = NULL;
-  for (std::vector<DrmPlane *>::iterator iter = primary_planes_.begin();
-       iter != primary_planes_.end(); ++iter) {
-    if ((*iter)->GetCrtcSupported(*crtc)) {
-      plane = *iter;
-      primary_planes_.erase(iter);
-      break;
-    }
-  }
-  for (std::vector<DrmPlane *>::iterator iter = overlay_planes_.begin();
-       !plane && iter != overlay_planes_.end(); ++iter) {
-    if ((*iter)->GetCrtcSupported(*crtc)) {
-      plane = *iter;
-      overlay_planes_.erase(iter);
-      break;
-    }
-  }
-  if (!plane) {
-    ALOGE("Failed to find plane for display %d", display);
-    return -ENOENT;
-  }
-  return composition_map_[display]->AddLayer(layer, bo, crtc, plane);
+  return 0;
+}
+
+int DrmComposition::SetDpmsMode(int display, uint32_t dpms_mode) {
+  return composition_map_[display]->SetDpmsMode(dpms_mode);
 }
 
-int DrmComposition::AddDpmsMode(int display, uint32_t dpms_mode) {
-  return composition_map_[display]->AddDpmsMode(dpms_mode);
+int DrmComposition::SetDisplayMode(int display, const DrmMode &display_mode) {
+  return composition_map_[display]->SetDisplayMode(display_mode);
 }
 
 std::unique_ptr<DrmDisplayComposition> DrmComposition::TakeDisplayComposition(
@@ -127,6 +102,23 @@ std::unique_ptr<DrmDisplayComposition> DrmComposition::TakeDisplayComposition(
   return std::move(composition_map_[display]);
 }
 
+int DrmComposition::Plan(std::map<int, DrmDisplayCompositor> &compositor_map) {
+  int ret = 0;
+  for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
+       iter != drm_->end_connectors(); ++iter) {
+    int display = (*iter)->display();
+    DrmDisplayComposition *comp = GetDisplayComposition(display);
+    ret = comp->Plan(compositor_map[display].squash_state(), &primary_planes_,
+                     &overlay_planes_);
+    if (ret) {
+      ALOGE("Failed to plan composition for dislay %d", display);
+      return ret;
+    }
+  }
+
+  return 0;
+}
+
 int DrmComposition::DisableUnusedPlanes() {
   for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
        iter != drm_->end_connectors(); ++iter) {
@@ -138,7 +130,8 @@ int DrmComposition::DisableUnusedPlanes() {
      * TODO: re-visit this and potentially disable leftover planes after the
      *       active compositions have gobbled up all they can
      */
-    if (comp->type() == DRM_COMPOSITION_TYPE_EMPTY)
+    if (comp->type() == DRM_COMPOSITION_TYPE_EMPTY ||
+        comp->type() == DRM_COMPOSITION_TYPE_MODESET)
       continue;
 
     DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);