#ifndef ANDROID_DRM_DISPLAY_COMPOSITION_H_
#define ANDROID_DRM_DISPLAY_COMPOSITION_H_
-#include "drm_hwcomposer.h"
+#include "drmcrtc.h"
+#include "drmhwcomposer.h"
#include "drmplane.h"
-#include "importer.h"
+#include "glworker.h"
+#include <sstream>
#include <vector>
+#include <hardware/gralloc.h>
#include <hardware/hardware.h>
#include <hardware/hwcomposer.h>
namespace android {
-typedef struct DrmCompositionLayer {
- DrmCompositionLayer();
- ~DrmCompositionLayer();
+class Importer;
+class Planner;
+class SquashState;
- hwc_layer_1_t layer;
- hwc_drm_bo_t bo;
- DrmCrtc *crtc;
- DrmPlane *plane;
-} DrmCompositionLayer_t;
-typedef std::vector<DrmCompositionLayer_t> DrmCompositionLayerVector_t;
+enum DrmCompositionType {
+ DRM_COMPOSITION_TYPE_EMPTY,
+ DRM_COMPOSITION_TYPE_FRAME,
+ DRM_COMPOSITION_TYPE_DPMS,
+ DRM_COMPOSITION_TYPE_MODESET,
+};
+
+struct DrmCompositionRegion {
+ DrmHwcRect<int> frame;
+ std::vector<size_t> source_layers;
+};
+
+class DrmCompositionPlane {
+ public:
+ enum class Type : int32_t {
+ kDisable,
+ kLayer,
+ kPrecomp,
+ kSquash,
+ };
+
+ DrmCompositionPlane() = default;
+ DrmCompositionPlane(DrmCompositionPlane &&rhs) = default;
+ DrmCompositionPlane &operator=(DrmCompositionPlane &&other) = default;
+ DrmCompositionPlane(Type type, DrmPlane *plane, DrmCrtc *crtc)
+ : type_(type), plane_(plane), crtc_(crtc) {
+ }
+ DrmCompositionPlane(Type type, DrmPlane *plane, DrmCrtc *crtc,
+ size_t source_layer)
+ : type_(type),
+ plane_(plane),
+ crtc_(crtc),
+ source_layers_(1, source_layer) {
+ }
+
+ Type type() const {
+ return type_;
+ }
+
+ DrmPlane *plane() const {
+ return plane_;
+ }
+ void set_plane(DrmPlane *plane) {
+ plane_ = plane;
+ }
+
+ DrmCrtc *crtc() const {
+ return crtc_;
+ }
+
+ std::vector<size_t> &source_layers() {
+ return source_layers_;
+ }
+
+ const std::vector<size_t> &source_layers() const {
+ return source_layers_;
+ }
+
+ private:
+ Type type_ = Type::kDisable;
+ DrmPlane *plane_ = NULL;
+ DrmCrtc *crtc_ = NULL;
+ std::vector<size_t> source_layers_;
+};
class DrmDisplayComposition {
public:
- DrmDisplayComposition();
+ DrmDisplayComposition() = default;
+ DrmDisplayComposition(const DrmDisplayComposition &) = delete;
~DrmDisplayComposition();
- int Init(DrmResources *drm, Importer *importer);
+ int Init(DrmResources *drm, DrmCrtc *crtc, Importer *importer,
+ Planner *planner, uint64_t frame_no);
+
+ int SetLayers(DrmHwcLayer *layers, size_t num_layers, bool geometry_changed);
+ int AddPlaneComposition(DrmCompositionPlane plane);
+ int AddPlaneDisable(DrmPlane *plane);
+ int SetDpmsMode(uint32_t dpms_mode);
+ int SetDisplayMode(const DrmMode &display_mode);
+
+ int Plan(SquashState *squash, std::vector<DrmPlane *> *primary_planes,
+ std::vector<DrmPlane *> *overlay_planes);
+
+ int FinalizeComposition();
+
+ int CreateNextTimelineFence();
+ int SignalSquashDone() {
+ return IncreaseTimelineToPoint(timeline_squash_done_);
+ }
+ int SignalPreCompDone() {
+ return IncreaseTimelineToPoint(timeline_pre_comp_done_);
+ }
+ int SignalCompositionDone() {
+ return IncreaseTimelineToPoint(timeline_);
+ }
+
+ std::vector<DrmHwcLayer> &layers() {
+ return layers_;
+ }
- int AddLayer(hwc_layer_1_t *layer, hwc_drm_bo_t *bo, DrmCrtc *crtc,
- DrmPlane *plane);
+ std::vector<DrmCompositionRegion> &squash_regions() {
+ return squash_regions_;
+ }
- int FinishComposition();
+ std::vector<DrmCompositionRegion> &pre_comp_regions() {
+ return pre_comp_regions_;
+ }
- DrmCompositionLayerVector_t *GetCompositionLayers();
+ std::vector<DrmCompositionPlane> &composition_planes() {
+ return composition_planes_;
+ }
+
+ bool geometry_changed() const {
+ return geometry_changed_;
+ }
+
+ uint64_t frame_no() const {
+ return frame_no_;
+ }
+
+ DrmCompositionType type() const {
+ return type_;
+ }
+
+ uint32_t dpms_mode() const {
+ return dpms_mode_;
+ }
+
+ const DrmMode &display_mode() const {
+ return display_mode_;
+ }
+
+ DrmCrtc *crtc() const {
+ return crtc_;
+ }
+
+ Importer *importer() const {
+ return importer_;
+ }
+
+ Planner *planner() const {
+ return planner_;
+ }
+
+ void Dump(std::ostringstream *out) const;
private:
- DrmDisplayComposition(const DrmDisplayComposition &) = delete;
+ bool validate_composition_type(DrmCompositionType desired);
+
+ int IncreaseTimelineToPoint(int point);
+
+ int FinalizeComposition(DrmHwcRect<int> *exclude_rects,
+ size_t num_exclude_rects);
+ void SeparateLayers(DrmHwcRect<int> *exclude_rects, size_t num_exclude_rects);
+ int CreateAndAssignReleaseFences();
+
+ DrmResources *drm_ = NULL;
+ DrmCrtc *crtc_ = NULL;
+ Importer *importer_ = NULL;
+ Planner *planner_ = NULL;
+
+ DrmCompositionType type_ = DRM_COMPOSITION_TYPE_EMPTY;
+ uint32_t dpms_mode_ = DRM_MODE_DPMS_ON;
+ DrmMode display_mode_;
- DrmResources *drm_;
- Importer *importer_;
+ int timeline_fd_ = -1;
+ int timeline_ = 0;
+ int timeline_current_ = 0;
+ int timeline_squash_done_ = 0;
+ int timeline_pre_comp_done_ = 0;
- int timeline_fd_;
- int timeline_;
+ bool geometry_changed_;
+ std::vector<DrmHwcLayer> layers_;
+ std::vector<DrmCompositionRegion> squash_regions_;
+ std::vector<DrmCompositionRegion> pre_comp_regions_;
+ std::vector<DrmCompositionPlane> composition_planes_;
- DrmCompositionLayerVector_t layers_;
+ uint64_t frame_no_ = 0;
};
}