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 DRM_HWCOMPOSER_SEPERATE_RECTS_H_
18 #define DRM_HWCOMPOSER_SEPERATE_RECTS_H_
19 
20 #include <stdint.h>
21 #include <vector>
22 
23 namespace seperate_rects {
24 
25 template <typename TFloat>
26 struct Rect {
27   union {
28     struct {
29       TFloat left, top, right, bottom;
30     };
31     struct {
32       TFloat x1, y1, x2, y2;
33     };
34     TFloat bounds[4];
35   };
36 
37   typedef TFloat TNum;
38 
RectRect39   Rect() {
40   }
41 
RectRect42   Rect(TFloat xx1, TFloat yy1, TFloat xx2, TFloat yy2)
43       : x1(xx1), y1(yy1), x2(xx2), y2(yy2) {
44   }
45 
RectRect46   Rect(const Rect &rhs) {
47     for (int i = 0; i < 4; i++)
48       bounds[i] = rhs.bounds[i];
49   }
50 
51   bool operator==(const Rect &rhs) const {
52     for (int i = 0; i < 4; i++) {
53       if (bounds[i] != rhs.bounds[i])
54         return false;
55     }
56 
57     return true;
58   }
59 };
60 
61 template <typename TUInt>
62 struct IdSet {
63  public:
64   typedef TUInt TId;
65 
IdSetIdSet66   IdSet() : bitset(0) {
67   }
68 
IdSetIdSet69   IdSet(TId id) : bitset(0) {
70     add(id);
71   }
72 
addIdSet73   void add(TId id) {
74     bitset |= ((TUInt)1) << id;
75   }
76 
subtractIdSet77   void subtract(TId id) {
78     bitset &= ~(((TUInt)1) << id);
79   }
80 
isEmptyIdSet81   bool isEmpty() const {
82     return bitset == 0;
83   }
84 
getBitsIdSet85   TUInt getBits() const {
86     return bitset;
87   }
88 
89   bool operator==(const IdSet<TId> &rhs) const {
90     return bitset == rhs.bitset;
91   }
92 
93   bool operator<(const IdSet<TId> &rhs) const {
94     return bitset < rhs.bitset;
95   }
96 
97   IdSet<TId> operator|(const IdSet<TId> &rhs) const {
98     IdSet ret;
99     ret.bitset = bitset | rhs.bitset;
100     return ret;
101   }
102 
103   IdSet<TId> operator|(TId id) const {
104     IdSet<TId> ret;
105     ret.bitset = bitset;
106     ret.add(id);
107     return ret;
108   }
109 
110   static const int max_elements = sizeof(TId) * 8;
111 
112  private:
113   TUInt bitset;
114 };
115 
116 template <typename TId, typename TNum>
117 struct RectSet {
118   IdSet<TId> id_set;
119   Rect<TNum> rect;
120 
RectSetRectSet121   RectSet(const IdSet<TId> &i, const Rect<TNum> &r) : id_set(i), rect(r) {
122   }
123 
124   bool operator==(const RectSet<TId, TNum> &rhs) const {
125     return id_set == rhs.id_set && rect == rhs.rect;
126   }
127 };
128 
129 // Seperates up to a maximum of 64 input rectangles into mutually non-
130 // overlapping rectangles that cover the exact same area and outputs those non-
131 // overlapping rectangles. Each output rectangle also includes the set of input
132 // rectangle indices that overlap the output rectangle encoded in a bitset. For
133 // example, an output rectangle that overlaps input rectangles in[0], in[1], and
134 // in[4], the bitset would be (ommitting leading zeroes) 10011.
135 void seperate_frects_64(const std::vector<Rect<float> > &in,
136                         std::vector<RectSet<uint64_t, float> > *out);
137 
138 }  // namespace seperate_rects
139 
140 #endif
141