seperate_rects.h

   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
  39   Rect() {
  40   }
  41
  42   Rect(TFloat xx1, TFloat yy1, TFloat xx2, TFloat yy2)
  43       : x1(xx1), y1(yy1), x2(xx2), y2(yy2) {
  44   }
  45
  46   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
  66   IdSet() : bitset(0) {
  67   }
  68
  69   IdSet(TId id) : bitset(0) {
  70     add(id);
  71   }
  72
  73   void add(TId id) {
  74     bitset |= ((TUInt)1) << id;
  75   }
  76
  77   void subtract(TId id) {
  78     bitset &= ~(((TUInt)1) << id);
  79   }
  80
  81   bool isEmpty() const {
  82     return bitset == 0;
  83   }
  84
  85   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
 121   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