1/*
2 * Copyright (C) 2015 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#ifndef ANDROID_DRM_PLATFORM_H_
18#define ANDROID_DRM_PLATFORM_H_
19
20#include "drmdisplaycomposition.h"
21#include "drmhwcomposer.h"
22
23#include <hardware/hardware.h>
24#include <hardware/hwcomposer.h>
25
26#include <map>
27#include <vector>
28
29namespace android {
30
31class DrmResources;
32
33class Importer {
34 public:
35  virtual ~Importer() {
36  }
37
38  // Creates a platform-specific importer instance
39  static Importer *CreateInstance(DrmResources *drm);
40
41  // Imports the buffer referred to by handle into bo.
42  //
43  // Note: This can be called from a different thread than ReleaseBuffer. The
44  //       implementation is responsible for ensuring thread safety.
45  virtual int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) = 0;
46
47  // Releases the buffer object (ie: does the inverse of ImportBuffer)
48  //
49  // Note: This can be called from a different thread than ImportBuffer. The
50  //       implementation is responsible for ensuring thread safety.
51  virtual int ReleaseBuffer(hwc_drm_bo_t *bo) = 0;
52};
53
54class Planner {
55 public:
56  class PlanStage {
57   public:
58    virtual ~PlanStage() {
59    }
60
61    virtual int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
62                                std::map<size_t, DrmHwcLayer *> &layers,
63                                DrmCrtc *crtc,
64                                std::vector<DrmPlane *> *planes) = 0;
65
66   protected:
67    // Removes and returns the next available plane from planes
68    static DrmPlane *PopPlane(std::vector<DrmPlane *> *planes) {
69      if (planes->empty())
70        return NULL;
71      DrmPlane *plane = planes->front();
72      planes->erase(planes->begin());
73      return plane;
74    }
75
76    // Finds and returns the squash layer from the composition
77    static DrmCompositionPlane *GetPrecomp(
78        std::vector<DrmCompositionPlane> *composition) {
79      auto l = GetPrecompIter(composition);
80      if (l == composition->end())
81        return NULL;
82      return &(*l);
83    }
84
85    // Inserts the given layer:plane in the composition right before the precomp
86    // layer
87    static int Emplace(std::vector<DrmCompositionPlane> *composition,
88                       std::vector<DrmPlane *> *planes,
89                       DrmCompositionPlane::Type type, DrmCrtc *crtc,
90                       size_t source_layer) {
91      DrmPlane *plane = PopPlane(planes);
92      if (!plane)
93        return -ENOENT;
94
95      auto precomp = GetPrecompIter(composition);
96      composition->emplace(precomp, type, plane, crtc, source_layer);
97      return 0;
98    }
99
100   private:
101    static std::vector<DrmCompositionPlane>::iterator GetPrecompIter(
102        std::vector<DrmCompositionPlane> *composition) {
103      return std::find_if(composition->begin(), composition->end(),
104                          [](const DrmCompositionPlane &p) {
105        return p.type() == DrmCompositionPlane::Type::kPrecomp;
106      });
107    }
108  };
109
110  // Creates a planner instance with platform-specific planning stages
111  static std::unique_ptr<Planner> CreateInstance(DrmResources *drm);
112
113  // Takes a stack of layers and provisions hardware planes for them. If the
114  // entire stack can't fit in hardware, the Planner may place the remaining
115  // layers in a PRECOMP plane. Layers in the PRECOMP plane will be composited
116  // using GL. PRECOMP planes should be placed above any 1:1 layer:plane
117  // compositions. If use_squash_fb is true, the Planner should try to reserve a
118  // plane at the highest z-order with type SQUASH.
119  //
120  // @layers: a map of index:layer of layers to composite
121  // @use_squash_fb: reserve a squash framebuffer
122  // @primary_planes: a vector of primary planes available for this frame
123  // @overlay_planes: a vector of overlay planes available for this frame
124  //
125  // Returns: A tuple with the status of the operation (0 for success) and
126  //          a vector of the resulting plan (ie: layer->plane mapping).
127  std::tuple<int, std::vector<DrmCompositionPlane>> ProvisionPlanes(
128      std::map<size_t, DrmHwcLayer *> &layers, bool use_squash_fb,
129      DrmCrtc *crtc, std::vector<DrmPlane *> *primary_planes,
130      std::vector<DrmPlane *> *overlay_planes);
131
132  template <typename T, typename... A>
133  void AddStage(A &&... args) {
134    stages_.emplace_back(
135        std::unique_ptr<PlanStage>(new T(std::forward(args)...)));
136  }
137
138 private:
139  std::vector<DrmPlane *> GetUsablePlanes(
140      DrmCrtc *crtc, std::vector<DrmPlane *> *primary_planes,
141      std::vector<DrmPlane *> *overlay_planes);
142
143  std::vector<std::unique_ptr<PlanStage>> stages_;
144};
145
146// This plan stage extracts all protected layers and places them on dedicated
147// planes.
148class PlanStageProtected : public Planner::PlanStage {
149 public:
150  int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
151                      std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
152                      std::vector<DrmPlane *> *planes);
153};
154
155// This plan stage provisions the precomp plane with any remaining layers that
156// are on top of the current precomp layers. This stage should be included in
157// all platforms before loosely allocating layers (i.e. PlanStageGreedy) if
158// any previous plan could have modified the precomp plane layers
159// (ex. PlanStageProtected).
160class PlanStagePrecomp : public Planner::PlanStage {
161 public:
162  int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
163                      std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
164                      std::vector<DrmPlane *> *planes);
165};
166
167// This plan stage places as many layers on dedicated planes as possible (first
168// come first serve), and then sticks the rest in a precomposition plane (if
169// needed).
170class PlanStageGreedy : public Planner::PlanStage {
171 public:
172  int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
173                      std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
174                      std::vector<DrmPlane *> *planes);
175};
176}
177#endif
178