src/lib/sw_engine/tvgSwCommon.h

   1 /*
   2  * Copyright (c) 2020-2021 Samsung Electronics Co., Ltd. All rights reserved.
   3
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10
  11  * The above copyright notice and this permission notice shall be included in all
  12  * copies or substantial portions of the Software.
  13
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22 #ifndef _TVG_SW_COMMON_H_
  23 #define _TVG_SW_COMMON_H_
  24
  25 #include "tvgCommon.h"
  26 #include "tvgRender.h"
  27
  28 #if 0
  29 #include <sys/time.h>
  30 static double timeStamp()
  31 {
  32    struct timeval tv;
  33    gettimeofday(&tv, NULL);
  34    return (tv.tv_sec + tv.tv_usec / 1000000.0);
  35 }
  36 #endif
  37
  38 #define SW_CURVE_TYPE_POINT 0
  39 #define SW_CURVE_TYPE_CUBIC 1
  40 #define SW_ANGLE_PI (180L << 16)
  41 #define SW_ANGLE_2PI (SW_ANGLE_PI << 1)
  42 #define SW_ANGLE_PI2 (SW_ANGLE_PI >> 1)
  43 #define SW_ANGLE_PI4 (SW_ANGLE_PI >> 2)
  44
  45 using SwCoord = signed long;
  46 using SwFixed = signed long long;
  47
  48 struct SwPoint
  49 {
  50     SwCoord x, y;
  51
  52     SwPoint& operator+=(const SwPoint& rhs)
  53     {
  54         x += rhs.x;
  55         y += rhs.y;
  56         return *this;
  57     }
  58
  59     SwPoint operator+(const SwPoint& rhs) const
  60     {
  61         return {x + rhs.x, y + rhs.y};
  62     }
  63
  64     SwPoint operator-(const SwPoint& rhs) const
  65     {
  66         return {x - rhs.x, y - rhs.y};
  67     }
  68
  69     bool operator==(const SwPoint& rhs) const
  70     {
  71         return (x == rhs.x && y == rhs.y);
  72     }
  73
  74     bool operator!=(const SwPoint& rhs) const
  75     {
  76         return (x != rhs.x || y != rhs.y);
  77     }
  78
  79     bool zero() const
  80     {
  81         if (x == 0 && y == 0) return true;
  82         else return false;
  83     }
  84
  85     bool small() const
  86     {
  87         //2 is epsilon...
  88         if (abs(x) < 2 && abs(y) < 2) return true;
  89         else return false;
  90     }
  91
  92 };
  93
  94 struct SwSize
  95 {
  96     SwCoord w, h;
  97 };
  98
  99 struct SwOutline
 100 {
 101     uint32_t*     cntrs;            //the contour end points
 102     uint32_t      cntrsCnt;         //number of contours in glyph
 103     uint32_t      reservedCntrsCnt;
 104     SwPoint*      pts;              //the outline's points
 105     uint32_t      ptsCnt;           //number of points in the glyph
 106     uint32_t      reservedPtsCnt;
 107     uint8_t*      types;            //curve type
 108     FillRule      fillRule;
 109     bool          opened;           //opened path?
 110 };
 111
 112 struct SwSpan
 113 {
 114     int16_t x, y;
 115     uint16_t len;
 116     uint8_t coverage;
 117 };
 118
 119 struct SwRleData
 120 {
 121     SwSpan *spans;
 122     uint32_t alloc;
 123     uint32_t size;
 124 };
 125
 126 struct SwBBox
 127 {
 128     SwPoint min, max;
 129
 130     void reset()
 131     {
 132         min.x = min.y = max.x = max.y = 0;
 133     }
 134 };
 135
 136 struct SwFill
 137 {
 138     struct SwLinear {
 139         float dx, dy;
 140         float len;
 141         float offset;
 142     };
 143
 144     struct SwRadial {
 145         float cx, cy;
 146         float a;
 147         float inva;
 148     };
 149
 150     union {
 151         SwLinear linear;
 152         SwRadial radial;
 153     };
 154
 155     uint32_t* ctable;
 156     FillSpread spread;
 157     float sx, sy;
 158
 159     bool translucent;
 160 };
 161
 162 struct SwStrokeBorder
 163 {
 164     uint32_t ptsCnt;
 165     uint32_t maxPts;
 166     SwPoint* pts;
 167     uint8_t* tags;
 168     int32_t start;     //index of current sub-path start point
 169     bool movable;      //true: for ends of lineto borders
 170 };
 171
 172 struct SwStroke
 173 {
 174     SwFixed angleIn;
 175     SwFixed angleOut;
 176     SwPoint center;
 177     SwFixed lineLength;
 178     SwFixed subPathAngle;
 179     SwPoint ptStartSubPath;
 180     SwFixed subPathLineLength;
 181     SwFixed width;
 182
 183     StrokeCap cap;
 184     StrokeJoin join;
 185     StrokeJoin joinSaved;
 186     SwFill* fill = nullptr;
 187
 188     SwStrokeBorder borders[2];
 189
 190     float sx, sy;
 191
 192     bool firstPt;
 193     bool openSubPath;
 194     bool handleWideStrokes;
 195 };
 196
 197 struct SwDashStroke
 198 {
 199     SwOutline* outline;
 200     float curLen;
 201     int32_t curIdx;
 202     Point ptStart;
 203     Point ptCur;
 204     float* pattern;
 205     uint32_t cnt;
 206     bool curOpGap;
 207 };
 208
 209 struct SwShape
 210 {
 211     SwOutline*   outline = nullptr;
 212     SwStroke*    stroke = nullptr;
 213     SwFill*      fill = nullptr;
 214     SwRleData*   rle = nullptr;
 215     SwRleData*   strokeRle = nullptr;
 216     SwBBox       bbox;           //Keep it boundary without stroke region. Using for optimal filling.
 217
 218     bool         rect = false;   //Fast Track: Othogonal rectangle?
 219 };
 220
 221 struct SwImage
 222 {
 223     SwOutline*   outline = nullptr;
 224     SwRleData*   rle = nullptr;
 225     uint32_t*    data = nullptr;
 226     uint32_t     w, h;
 227 };
 228
 229 struct SwBlender
 230 {
 231     uint32_t (*join)(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 232     uint32_t (*alpha)(uint32_t rgba);
 233 };
 234
 235 struct SwCompositor;
 236
 237 struct SwSurface : Surface
 238 {
 239     SwBlender blender;                    //mandatory
 240     SwCompositor* compositor = nullptr;   //compositor (optional)
 241 };
 242
 243 struct SwCompositor : Compositor
 244 {
 245     SwSurface* recoverSfc;                  //Recover surface when composition is started
 246     SwCompositor* recoverCmp;               //Recover compositor when composition is done
 247     SwImage image;
 248     SwBBox bbox;
 249     bool valid;
 250 };
 251
 252 struct SwMpool
 253 {
 254     SwOutline* outline = nullptr;
 255     SwOutline* strokeOutline = nullptr;
 256     unsigned allocSize = 0;
 257 };
 258
 259 static inline SwCoord TO_SWCOORD(float val)
 260 {
 261     return SwCoord(val * 64.0f);
 262 }
 263
 264 static inline uint32_t ALPHA_BLEND(uint32_t c, uint32_t a)
 265 {
 266     return (((((c >> 8) & 0x00ff00ff) * a + 0x00ff00ff) & 0xff00ff00) +
 267             ((((c & 0x00ff00ff) * a + 0x00ff00ff) >> 8) & 0x00ff00ff));
 268 }
 269
 270 static inline uint32_t COLOR_INTERPOLATE(uint32_t c1, uint32_t a1, uint32_t c2, uint32_t a2)
 271 {
 272     auto t = (((c1 & 0xff00ff) * a1 + (c2 & 0xff00ff) * a2) >> 8) & 0xff00ff;
 273     c1 = (((c1 >> 8) & 0xff00ff) * a1 + ((c2 >> 8) & 0xff00ff) * a2) & 0xff00ff00;
 274     return (c1 |= t);
 275 }
 276
 277 static inline uint32_t ALPHA_MULTIPLY(uint32_t c, uint32_t a)
 278 {
 279     return ((c * a + 0xff) >> 8);
 280 }
 281
 282 static inline SwCoord HALF_STROKE(float width)
 283 {
 284     return TO_SWCOORD(width * 0.5f);
 285 }
 286
 287 int64_t mathMultiply(int64_t a, int64_t b);
 288 int64_t mathDivide(int64_t a, int64_t b);
 289 int64_t mathMulDiv(int64_t a, int64_t b, int64_t c);
 290 void mathRotate(SwPoint& pt, SwFixed angle);
 291 SwFixed mathTan(SwFixed angle);
 292 SwFixed mathAtan(const SwPoint& pt);
 293 SwFixed mathCos(SwFixed angle);
 294 SwFixed mathSin(SwFixed angle);
 295 void mathSplitCubic(SwPoint* base);
 296 SwFixed mathDiff(SwFixed angle1, SwFixed angle2);
 297 SwFixed mathLength(const SwPoint& pt);
 298 bool mathSmallCubic(const SwPoint* base, SwFixed& angleIn, SwFixed& angleMid, SwFixed& angleOut);
 299 SwFixed mathMean(SwFixed angle1, SwFixed angle2);
 300 SwPoint mathTransform(const Point* to, const Matrix* transform);
 301 bool mathUpdateOutlineBBox(const SwOutline* outline, const SwBBox& clipRegion, SwBBox& renderRegion);
 302
 303 void shapeReset(SwShape* shape);
 304 bool shapePrepare(SwShape* shape, const Shape* sdata, const Matrix* transform, const SwBBox& clipRegion, SwBBox& renderRegion, SwMpool* mpool, unsigned tid);
 305 bool shapePrepared(const SwShape* shape);
 306 bool shapeGenRle(SwShape* shape, const Shape* sdata, bool antiAlias, bool hasComposite);
 307 void shapeDelOutline(SwShape* shape, SwMpool* mpool, uint32_t tid);
 308 void shapeResetStroke(SwShape* shape, const Shape* sdata, const Matrix* transform);
 309 bool shapeGenStrokeRle(SwShape* shape, const Shape* sdata, const Matrix* transform, const SwBBox& clipRegion, SwBBox& renderRegion, SwMpool* mpool, unsigned tid);
 310 void shapeFree(SwShape* shape);
 311 void shapeDelStroke(SwShape* shape);
 312 bool shapeGenFillColors(SwShape* shape, const Fill* fill, const Matrix* transform, SwSurface* surface, uint32_t opacity, bool ctable);
 313 bool shapeGenStrokeFillColors(SwShape* shape, const Fill* fill, const Matrix* transform, SwSurface* surface, uint32_t opacity, bool ctable);
 314 void shapeResetFill(SwShape* shape);
 315 void shapeResetStrokeFill(SwShape* shape);
 316 void shapeDelFill(SwShape* shape);
 317 void shapeDelStrokeFill(SwShape* shape);
 318
 319 void strokeReset(SwStroke* stroke, const Shape* shape, const Matrix* transform);
 320 bool strokeParseOutline(SwStroke* stroke, const SwOutline& outline);
 321 SwOutline* strokeExportOutline(SwStroke* stroke, SwMpool* mpool, unsigned tid);
 322 void strokeFree(SwStroke* stroke);
 323
 324 bool imagePrepare(SwImage* image, const Matrix* transform, const SwBBox& clipRegion, SwBBox& renderRegion, SwMpool* mpool, unsigned tid);
 325 bool imagePrepared(const SwImage* image);
 326 bool imageGenRle(SwImage* image, TVG_UNUSED const Picture* pdata, const SwBBox& renderRegion, bool antiAlias);
 327 void imageDelOutline(SwImage* image, SwMpool* mpool, uint32_t tid);
 328 void imageReset(SwImage* image);
 329 void imageFree(SwImage* image);
 330
 331 bool fillGenColorTable(SwFill* fill, const Fill* fdata, const Matrix* transform, SwSurface* surface, uint32_t opacity, bool ctable);
 332 void fillReset(SwFill* fill);
 333 void fillFree(SwFill* fill);
 334 void fillFetchLinear(const SwFill* fill, uint32_t* dst, uint32_t y, uint32_t x, uint32_t len);
 335 void fillFetchRadial(const SwFill* fill, uint32_t* dst, uint32_t y, uint32_t x, uint32_t len);
 336
 337 SwRleData* rleRender(SwRleData* rle, const SwOutline* outline, const SwBBox& renderRegion, bool antiAlias);
 338 void rleFree(SwRleData* rle);
 339 void rleReset(SwRleData* rle);
 340 void rleClipPath(SwRleData *rle, const SwRleData *clip);
 341 void rleClipRect(SwRleData *rle, const SwBBox* clip);
 342
 343 SwMpool* mpoolInit(uint32_t threads);
 344 bool mpoolTerm(SwMpool* mpool);
 345 bool mpoolClear(SwMpool* mpool);
 346 SwOutline* mpoolReqOutline(SwMpool* mpool, unsigned idx);
 347 void mpoolRetOutline(SwMpool* mpool, unsigned idx);
 348 SwOutline* mpoolReqStrokeOutline(SwMpool* mpool, unsigned idx);
 349 void mpoolRetStrokeOutline(SwMpool* mpool, unsigned idx);
 350
 351 bool rasterCompositor(SwSurface* surface);
 352 bool rasterGradientShape(SwSurface* surface, SwShape* shape, unsigned id);
 353 bool rasterSolidShape(SwSurface* surface, SwShape* shape, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 354 bool rasterImage(SwSurface* surface, SwImage* image, const Matrix* transform, const SwBBox& bbox, uint32_t opacity);
 355 bool rasterStroke(SwSurface* surface, SwShape* shape, uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 356 bool rasterGradientStroke(SwSurface* surface, SwShape* shape, unsigned id);
 357 bool rasterClear(SwSurface* surface);
 358 void rasterRGBA32(uint32_t *dst, uint32_t val, uint32_t offset, int32_t len);
 359
 360 #endif /* _TVG_SW_COMMON_H_ */