src/subtitles/Rasterizer.h

   1 /*
   2  *      Copyright (C) 2003-2006 Gabest
   3  *      http://www.gabest.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GNU Make; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #pragma once
  23
  24 #include <boost/smart_ptr.hpp>
  25 #include <vector>
  26 #include "../SubPic/ISubPic.h"
  27 #include "xy_malloc.h"
  28
  29 #ifdef _OPENMP
  30 #include <omp.h>
  31 #endif
  32
  33 #define PT_MOVETONC 0xfe
  34 #define PT_BSPLINETO 0xfc
  35 #define PT_BSPLINEPATCHTO 0xfa
  36
  37 typedef struct {
  38     int left, top;
  39     int w, h;                   // width, height
  40     unsigned char *buffer;      // w x h buffer
  41 } Bitmap;
  42
  43 struct PathData
  44 {
  45 public:
  46     PathData();
  47     ~PathData();
  48
  49     PathData(const PathData&);//important! disable default copy constructor
  50     const PathData& operator=(const PathData&);
  51     void _TrashPath();
  52     bool BeginPath(HDC hdc);
  53     bool EndPath(HDC hdc);
  54     bool PartialBeginPath(HDC hdc, bool bClearPath);
  55     bool PartialEndPath(HDC hdc, long dx, long dy);
  56
  57     void AlignLeftTop(CPoint *left_top, CSize *size);
  58
  59     BYTE* mpPathTypes;
  60     POINT* mpPathPoints;
  61     int mPathPoints;
  62 };
  63
  64 typedef ::boost::shared_ptr<const PathData> SharedPtrConstPathData;
  65 typedef ::boost::shared_ptr<PathData> SharedPtrPathData;
  66
  67 class ScanLineData
  68 {
  69     bool fFirstSet;
  70     CPoint firstp, lastp;
  71
  72 private:
  73     int mWidth, mHeight;
  74
  75     typedef std::pair<unsigned __int64, unsigned __int64> tSpan;
  76     typedef std::vector<tSpan> tSpanBuffer;
  77
  78     tSpanBuffer mOutline;
  79     tSpanBuffer mWideOutline;
  80     int mWideBorder;
  81
  82     struct Edge {
  83         int next;
  84         int posandflag;
  85     } *mpEdgeBuffer;
  86     unsigned mEdgeHeapSize;
  87     unsigned mEdgeNext;
  88
  89     unsigned int* mpScanBuffer;
  90
  91     typedef unsigned char byte;
  92
  93 private:
  94     void _ReallocEdgeBuffer(int edges);
  95     void _EvaluateBezier(const PathData& path_data, int ptbase, bool fBSpline);
  96     void _EvaluateLine(const PathData& path_data, int pt1idx, int pt2idx);
  97     void _EvaluateLine(int x0, int y0, int x1, int y1);
  98     static void _OverlapRegion(tSpanBuffer& dst, tSpanBuffer& src, int dx, int dy);
  99
 100 public:
 101     ScanLineData();
 102     virtual ~ScanLineData();
 103
 104     bool ScanConvert(const PathData& path_data, const CSize& size);
 105     bool CreateWidenedRegion(int borderX, int borderY);
 106     void DeleteOutlines();
 107
 108     friend class Rasterizer;
 109 };
 110
 111 class ScanLineData2:public ScanLineData
 112 {
 113 public:
 114     ScanLineData2():mPathOffsetX(0),mPathOffsetY(0){}
 115
 116     void SetOffset(const CPoint& offset)
 117     {
 118         mPathOffsetX = offset.x;
 119         mPathOffsetY = offset.y;
 120     }
 121 protected:
 122     int mPathOffsetX, mPathOffsetY;
 123
 124     friend class Rasterizer;
 125 };
 126
 127 typedef ::boost::shared_ptr<const ScanLineData2> SharedPtrConstScanLineData2;
 128 typedef ::boost::shared_ptr<ScanLineData2> SharedPtrScanLineData2;
 129
 130 typedef ::boost::shared_ptr<BYTE> SharedPtrByte;
 131
 132 struct Overlay
 133 {
 134 public:
 135     Overlay()
 136     {
 137         memset(this, 0, sizeof(*this));//todo: fix me. not safe.
 138     }
 139     ~Overlay()
 140     {
 141         CleanUp();
 142     }
 143
 144     void CleanUp()
 145     {
 146         xy_free(mpOverlayBuffer.base);
 147         memset(&mpOverlayBuffer, 0, sizeof(mpOverlayBuffer));
 148         mOverlayWidth=mOverlayHeight=mOverlayPitch=0;
 149         mfWideOutlineEmpty = false;
 150     }
 151
 152     void FillAlphaMash(byte* outputAlphaMask, bool fBody, bool fBorder,
 153         int x, int y, int w, int h,
 154         const byte* pAlphaMask, int pitch, DWORD color_alpha);
 155
 156     Overlay* GetSubpixelVariance(unsigned int xshift, unsigned int yshift);
 157
 158     struct {
 159         byte *base;
 160         byte *body;
 161         byte *border;
 162     } mpOverlayBuffer;
 163     int mOffsetX, mOffsetY;
 164     int mWidth, mHeight;
 165
 166     int mOverlayWidth, mOverlayHeight, mOverlayPitch;
 167
 168     bool mfWideOutlineEmpty;//specially for blur
 169 private:
 170     void _DoFillAlphaMash(byte* outputAlphaMask, const byte* pBody, const byte* pBorder,
 171         int x, int y, int w, int h,
 172         const byte* pAlphaMask, int pitch, DWORD color_alpha);
 173 };
 174
 175 typedef ::boost::shared_ptr<Overlay> SharedPtrOverlay;
 176
 177 typedef ::boost::shared_array<BYTE> SharedArrayByte;
 178
 179 struct DrawItem
 180 {
 181     SharedPtrOverlay overlay;
 182     CRect clip_rect;
 183     SharedArrayByte alpha_mask;
 184     int xsub;
 185     int ysub;
 186     DWORD switchpts[6];
 187     bool fBody;
 188     bool fBorder;
 189 };
 190
 191 typedef ::boost::shared_ptr<DrawItem> SharedPtrDrawItem;
 192
 193 class Rasterizer
 194 {
 195 private:
 196     typedef unsigned char byte;
 197
 198     struct DM
 199     {
 200         enum
 201         {
 202             SSE2 = 1,
 203             ALPHA_MASK = 1<<1,
 204             SINGLE_COLOR = 1<<2,
 205             BODY = 1<<3,
 206             AYUV_PLANAR = 1<<4
 207         };
 208     };
 209 public:
 210     static bool Rasterize(const ScanLineData2& scan_line_data2, int xsub, int ysub, SharedPtrOverlay overlay);
 211     static bool Blur(const Overlay& input_overlay, int fBlur, double fGaussianBlur, SharedPtrOverlay output_overlay);
 212
 213     static DrawItem* CreateDrawItem(SubPicDesc& spd,
 214         SharedPtrOverlay overlay,
 215         const CRect& clipRect,
 216         SharedArrayByte pAlphaMask,
 217         int xsub, int ysub,
 218         const DWORD* switchpts, bool fBody, bool fBorder);
 219
 220     static SharedPtrByte CompositeAlphaMask(SubPicDesc& spd, SharedPtrOverlay overlay, const CRect& clipRect, byte* pAlphaMask,
 221         int xsub, int ysub, const DWORD* switchpts, bool fBody, bool fBorder,
 222         CRect *outputDirtyRect);
 223     static CRect Draw(SubPicDesc& spd, DrawItem& draw_item);
 224
 225     static CRect DryDraw(SubPicDesc& spd, DrawItem& draw_item);
 226
 227     static CRect DryDraw(SubPicDesc& spd,
 228         SharedPtrOverlay overlay,
 229         const CRect& clipRect,
 230         byte* pAlphaMask,
 231         int xsub, int ysub,
 232         const DWORD* switchpts, bool fBody, bool fBorder);
 233
 234     static CRect Draw(SubPicDesc& spd,
 235         SharedPtrOverlay overlay,
 236         const CRect& clipRect,
 237         byte* pAlphaMask,
 238         int xsub, int ysub,
 239         const DWORD* switchpts, bool fBody, bool fBorder);
 240
 241         static void FillSolidRect(SubPicDesc& spd, int x, int y, int nWidth, int nHeight, DWORD lColor);
 242
 243 };
 244