: fFirstSet(false)

, mpPathTypes(nullptr)

, mpPathPoints(nullptr)

, mPathPoints(0)

, m_bUseAVX2(false)

, mpEdgeBuffer(nullptr)

, mEdgeHeapSize(0)

, mEdgeNext(0)

, mpScanBuffer(nullptr)

{

int cpuInfo[4];

__cpuid(cpuInfo, 0);

if (cpuInfo[0] < 7) {

return;

}

__cpuidex(cpuInfo, 7, 0);

m_bUseAVX2 = !!(cpuInfo[1] & (1 << 5)) && (_xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6;

{

delete [] mpPathTypes;

delete [] mpPathPoints;

mpPathTypes = nullptr;

mpPathPoints = nullptr;

mPathPoints = 0;

{

Edge* pNewEdgeBuffer = (Edge*)realloc(mpEdgeBuffer, sizeof(Edge) * edges);

if (pNewEdgeBuffer) {

mpEdgeBuffer = pNewEdgeBuffer;

mEdgeHeapSize = edges;

} else {

AfxThrowMemoryException();

}

{

const POINT* pt0 = mpPathPoints + ptbase;

const POINT* pt1 = mpPathPoints + ptbase + 1;

const POINT* pt2 = mpPathPoints + ptbase + 2;

const POINT* pt3 = mpPathPoints + ptbase + 3;

double x0 = pt0->x;

double x1 = pt1->x;

double x2 = pt2->x;

double x3 = pt3->x;

double y0 = pt0->y;

double y1 = pt1->y;

double y2 = pt2->y;

double y3 = pt3->y;

double cx3, cx2, cx1, cx0, cy3, cy2, cy1, cy0;

if (fBSpline) {

// 1 [-1 +3 -3 +1]

// - * [+3 -6 +3 0]

// 6 [-3 0 +3 0]

// [+1 +4 +1 0]

double _1div6 = 1.0 / 6.0;

cx3 = _1div6 * (- x0 + 3 * x1 - 3 * x2 + x3);

cx2 = _1div6 * (3 * x0 - 6 * x1 + 3 * x2);

cx1 = _1div6 * (-3 * x0 + 3 * x2);

cx0 = _1div6 * (x0 + 4 * x1 + 1 * x2);

cy3 = _1div6 * (- y0 + 3 * y1 - 3 * y2 + y3);

cy2 = _1div6 * (3 * y0 - 6 * y1 + 3 * y2);

cy1 = _1div6 * (-3 * y0 + 3 * y2);

cy0 = _1div6 * (y0 + 4 * y1 + 1 * y2);

} else { // bezier

// [-1 +3 -3 +1]

// [+3 -6 +3 0]

// [-3 +3 0 0]

// [+1 0 0 0]

cx3 = - x0 + 3 * x1 - 3 * x2 + x3;

cx2 = 3 * x0 - 6 * x1 + 3 * x2;

cx1 = -3 * x0 + 3 * x1;

cx0 = x0;

cy3 = - y0 + 3 * y1 - 3 * y2 + y3;

cy2 = 3 * y0 - 6 * y1 + 3 * y2;

cy1 = -3 * y0 + 3 * y1;

cy0 = y0;

}

//

// This equation is from Graphics Gems I.

//

// The idea is that since we're approximating a cubic curve with lines,

// any error we incur is due to the curvature of the line, which we can

// estimate by calculating the maximum acceleration of the curve. For

// a cubic, the acceleration (second derivative) is a line, meaning that

// the absolute maximum acceleration must occur at either the beginning

// (|c2|) or the end (|c2+c3|). Our bounds here are a little more

// conservative than that, but that's okay.

//

// If the acceleration of the parametric formula is zero (c2 = c3 = 0),

// that component of the curve is linear and does not incur any error.

// If a=0 for both X and Y, the curve is a line segment and we can

// use a step size of 1.

double maxaccel1 = fabs(2 * cy2) + fabs(6 * cy3);

double maxaccel2 = fabs(2 * cx2) + fabs(6 * cx3);

double maxaccel = maxaccel1 > maxaccel2 ? maxaccel1 : maxaccel2;

double h = 1.0;

if (maxaccel > 8.0) {

h = sqrt(8.0 / maxaccel);

}

if (!fFirstSet) {

firstp.x = (LONG)cx0;

firstp.y = (LONG)cy0;

lastp = firstp;

fFirstSet = true;

}

for (double t = 0; t < 1.0; t += h) {

double x = cx0 + t * (cx1 + t * (cx2 + t * cx3));

double y = cy0 + t * (cy1 + t * (cy2 + t * cy3));

_EvaluateLine(lastp.x, lastp.y, (int)x, (int)y);

}

double x = cx0 + cx1 + cx2 + cx3;

double y = cy0 + cy1 + cy2 + cy3;

_EvaluateLine(lastp.x, lastp.y, (int)x, (int)y);

{

const POINT* pt1 = mpPathPoints + pt1idx;

const POINT* pt2 = mpPathPoints + pt2idx;

_EvaluateLine(pt1->x, pt1->y, pt2->x, pt2->y);

{

if (lastp.x != x0 || lastp.y != y0) {

_EvaluateLine(lastp.x, lastp.y, x0, y0);

}

if (!fFirstSet) {

firstp.x = x0;

firstp.y = y0;

fFirstSet = true;

}

lastp.x = x1;

lastp.y = y1;

if (y1 > y0) {

_EvaluateLine<LINE_UP>(x0, y0, x1, y1);

} else if (y1 < y0) {

_EvaluateLine<LINE_DOWN>(x1, y1, x0, y0);

}

{

__int64 xacc = (__int64)x0 << 13;

// prestep

int dy = y1 - y0;

int y = ((y0 + 3) & ~7) + 4;

int iy = y >> 3;

y1 = (y1 - 5) >> 3;

if (iy <= y1) {

__int64 invslope = (__int64(x1 - x0) << 16) / dy;

if (mEdgeNext + y1 + 1 - iy > mEdgeHeapSize) {

unsigned int nSize = mEdgeHeapSize * 2;

while (mEdgeNext + y1 + 1 - iy > nSize) {

nSize *= 2;

}

_ReallocEdgeBuffer(nSize);

}

xacc += (invslope * (y - y0)) >> 3;

while (iy <= y1) {

int ix = (int)((xacc + 32768) >> 16);

mpEdgeBuffer[mEdgeNext].next = mpScanBuffer[iy];

mpEdgeBuffer[mEdgeNext].posandflag = (ix << 1) | flag;

mpScanBuffer[iy] = mEdgeNext++;

++iy;

xacc += invslope;

}

}

{

_TrashPath();

return !!::BeginPath(hdc);

{

::CloseFigure(hdc);

if (::EndPath(hdc)) {

mPathPoints = GetPath(hdc, nullptr, nullptr, 0);

if (!mPathPoints) {

return true;

}

mpPathTypes = (BYTE*)malloc(sizeof(BYTE) * mPathPoints);

mpPathPoints = (POINT*)malloc(sizeof(POINT) * mPathPoints);

if (mPathPoints == GetPath(hdc, mpPathPoints, mpPathTypes, mPathPoints)) {

return true;

}

}

::AbortPath(hdc);

return false;

{

if (bClearPath) {

_TrashPath();

}

return !!::BeginPath(hdc);

{

::CloseFigure(hdc);

if (::EndPath(hdc)) {

int nPoints;

BYTE* pNewTypes;

POINT* pNewPoints;

nPoints = GetPath(hdc, nullptr, nullptr, 0);

if (!nPoints) {

return true;

}

pNewTypes = (BYTE*)realloc(mpPathTypes, (mPathPoints + nPoints) * sizeof(BYTE));

pNewPoints = (POINT*)realloc(mpPathPoints, (mPathPoints + nPoints) * sizeof(POINT));

if (pNewTypes) {

mpPathTypes = pNewTypes;

}

if (pNewPoints) {

mpPathPoints = pNewPoints;

}

BYTE* pTypes = DEBUG_NEW BYTE[nPoints];

POINT* pPoints = DEBUG_NEW POINT[nPoints];

if (pNewTypes && pNewPoints && nPoints == GetPath(hdc, pPoints, pTypes, nPoints)) {

for (ptrdiff_t i = 0; i < nPoints; ++i) {

mpPathPoints[mPathPoints + i].x = pPoints[i].x + dx;

mpPathPoints[mPathPoints + i].y = pPoints[i].y + dy;

mpPathTypes[mPathPoints + i] = pTypes[i];

}

mPathPoints += nPoints;

delete [] pTypes;

delete [] pPoints;

return true;

} else {

DebugBreak();

}

delete [] pTypes;

delete [] pPoints;

}

::AbortPath(hdc);

return false;

{

try {

int lastmoveto = INT_MAX;

int i;

// Drop any outlines we may have.

m_pOutlineData = std::make_shared<COutlineData>();

// Determine bounding box

if (!mPathPoints) {

return false;

}

int minx = INT_MAX;

int miny = INT_MAX;

int maxx = INT_MIN;

int maxy = INT_MIN;

for (i = 0; i < mPathPoints; ++i) {

int ix = mpPathPoints[i].x;

int iy = mpPathPoints[i].y;

if (ix < minx) {

minx = ix;

}

if (ix > maxx) {

maxx = ix;

}

if (iy < miny) {

miny = iy;

}

if (iy > maxy) {

maxy = iy;

}

}

minx = (minx >> 3) & ~7;

miny = (miny >> 3) & ~7;

maxx = (maxx + 7) >> 3;

maxy = (maxy + 7) >> 3;

for (i = 0; i < mPathPoints; ++i) {

mpPathPoints[i].x -= minx * 8;

mpPathPoints[i].y -= miny * 8;

}

if (minx > maxx || miny > maxy) {

_TrashPath();

return true;

}

m_pOutlineData->mWidth = maxx + 1 - minx;

m_pOutlineData->mHeight = maxy + 1 - miny;

m_pOutlineData->mPathOffsetX = minx;

m_pOutlineData->mPathOffsetY = miny;

// Initialize edge buffer. We use edge 0 as a sentinel.

mEdgeNext = 1;

mEdgeHeapSize = 2048;

mpEdgeBuffer = (Edge*)malloc(sizeof(Edge) * mEdgeHeapSize);

if (!mpEdgeBuffer) {

TRACE(_T("Rasterizer::ScanConvert: Failed to allocate mpEdgeBuffer\n"));

return false;

}

// Initialize scanline list.

mpScanBuffer = DEBUG_NEW unsigned int[m_pOutlineData->mHeight];

ZeroMemory(mpScanBuffer, m_pOutlineData->mHeight * sizeof(unsigned int));

// Scan convert the outline. Yuck, Bezier curves....

// Unfortunately, Windows 95/98 GDI has a bad habit of giving us text

// paths with all but the first figure left open, so we can't rely

// on the PT_CLOSEFIGURE flag being used appropriately.

fFirstSet = false;

firstp.x = firstp.y = 0;

lastp.x = lastp.y = 0;

for (i = 0; i < mPathPoints; ++i) {

BYTE t = mpPathTypes[i] & ~PT_CLOSEFIGURE;

switch (t) {

case PT_MOVETO:

if (lastmoveto >= 0 && firstp != lastp) {

_EvaluateLine(lastp.x, lastp.y, firstp.x, firstp.y);

}

lastmoveto = i;

fFirstSet = false;

lastp = mpPathPoints[i];

break;

case PT_MOVETONC:

break;

case PT_LINETO:

if (mPathPoints - (i - 1) >= 2) {

_EvaluateLine(i - 1, i);

}

break;

case PT_BEZIERTO:

if (mPathPoints - (i - 1) >= 4) {

_EvaluateBezier(i - 1, false);

}

i += 2;

break;

case PT_BSPLINETO:

if (mPathPoints - (i - 1) >= 4) {

_EvaluateBezier(i - 1, true);

}

i += 2;

break;

case PT_BSPLINEPATCHTO:

if (mPathPoints - (i - 3) >= 4) {

_EvaluateBezier(i - 3, true);

}

break;

}

}

if (lastmoveto >= 0 && firstp != lastp) {

_EvaluateLine(lastp.x, lastp.y, firstp.x, firstp.y);

}

// Free the path since we don't need it anymore.

_TrashPath();

// Convert the edges to spans. We couldn't do this before because some of

// the regions may have winding numbers >+1 and it would have been a pain

// to try to adjust the spans on the fly. We use one heap to detangle

// a scanline's worth of edges from the singly-linked lists, and another

// to collect the actual scans.

std::vector<int> heap;

m_pOutlineData->mOutline.reserve(mEdgeNext / 2);

for (__int64 y = 0; y < m_pOutlineData->mHeight; ++y) {

int count = 0;

// Detangle scanline into edge heap.

for (size_t ptr = (mpScanBuffer[y] & (unsigned int)(-1)); ptr; ptr = mpEdgeBuffer[ptr].next) {

heap.emplace_back(mpEdgeBuffer[ptr].posandflag);

}

// Sort edge heap. Note that we conveniently made the opening edges

// one more than closing edges at the same spot, so we won't have any

// problems with abutting spans.

std::sort(heap.begin(), heap.end()/*begin() + heap.size()*/);

// Process edges and add spans. Since we only check for a non-zero

// winding number, it doesn't matter which way the outlines go!

auto itX1 = heap.cbegin();

auto itX2 = heap.cend(); // begin() + heap.size();

size_t x1 = 0;

size_t x2;

for (; itX1 != itX2; ++itX1) {

size_t x = *itX1;

if (!count) {

x1 = (x >> 1);

}

if (x & LINE_UP) {

++count;

} else {

--count;

}

if (!count) {

x2 = (x >> 1);

if (x2 > x1) {

m_pOutlineData->mOutline.emplace_back((y << 32) + x1 + 0x4000000040000000i64, (y << 32) + x2 + 0x4000000040000000i64); // G: damn Avery, this is evil! :)

}

}

}

heap.clear();

}

// Dump the edge and scan buffers, since we no longer need them.

free(mpEdgeBuffer);

delete[] mpScanBuffer;

// All done!

return true;

} catch (CMemoryException* e) {

TRACE(_T("Rasterizer::ScanConvert: Memory allocation failed\n"));

free(mpEdgeBuffer);

delete[] mpScanBuffer;

e->Delete();

return false;

}

{

tSpanBuffer temp;

temp.reserve(dst.size() + src.size());

dst.swap(temp);

auto itA = temp.cbegin();

auto itAE = temp.cend();

auto itB = src.cbegin();

auto itBE = src.cend();

// Don't worry -- even if dy<0 this will still work! // G: hehe, the evil twin :)

unsigned __int64 offset1 = (((__int64)dy) << 32) - dx;

unsigned __int64 offset2 = (((__int64)dy) << 32) + dx;

while (itA != itAE && itB != itBE) {

if (itB->first + offset1 < itA->first) {

// B span is earlier. Use it.

unsigned __int64 x1 = itB->first + offset1;

unsigned __int64 x2 = itB->second + offset2;

++itB;

// B spans don't overlap, so begin merge loop with A first.

for (;;) {

while (itA != itAE && itA->first <= x2) {

x2 = std::max(x2, itA->second);

++itA;

}

// If we run out of B spans or the B span doesn't overlap,

// then the next A span can't either (because A spans don't

// overlap) and we exit.

if (itB == itBE || itB->first + offset1 > x2) {

break;

}

do {

x2 = std::max(x2, itB->second + offset2);

++itB;

} while (itB != itBE && itB->first + offset1 <= x2);

// If we run out of A spans or the A span doesn't overlap,

// then the next B span can't either (because B spans don't

// overlap) and we exit.

if (itA == itAE || itA->first > x2) {

break;

}

}

// Flush span.

dst.emplace_back(x1, x2);

} else {

// A span is earlier. Use it.

unsigned __int64 x1 = itA->first;

unsigned __int64 x2 = itA->second;

++itA;

// A spans don't overlap, so begin merge loop with B first.

for (;;) {

while (itB != itBE && itB->first + offset1 <= x2) {

x2 = std::max(x2, itB->second + offset2);

++itB;

}

// If we run out of A spans or the A span doesn't overlap,

// then the next B span can't either (because B spans don't

// overlap) and we exit.

if (itA == itAE || itA->first > x2) {

break;

}

do {

x2 = std::max(x2, itA->second);

++itA;

} while (itA != itAE && itA->first <= x2);

// If we run out of B spans or the B span doesn't overlap,

// then the next A span can't either (because A spans don't

// overlap) and we exit.

if (itB == itBE || itB->first + offset1 > x2) {

break;

}

}

// Flush span.

dst.emplace_back(x1, x2);

}

}

// Copy over leftover spans.

while (itA != itAE) {

dst.emplace_back(*itA);

++itA;

}

while (itB != itBE) {

unsigned __int64 x1 = itB->first + offset1;

unsigned __int64 x2 = itB->second + offset2;

++itB;

while (itB != itBE && itB->first + offset1 <= x2) {

x2 = std::max(x2, itB->second + offset2);

++itB;

}

dst.emplace_back(x1, x2);

}

{

if (m_pOutlineData->mOutline.empty()) {

return true;

}

if (rx < 0) {

rx = 0;

}

if (ry < 0) {

ry = 0;

}

m_pOutlineData->mWideBorder = std::max(rx, ry);

if (m_pEllipse) {

CreateWidenedRegionFast(rx, ry);

} else if (ry > 0) {

// Do a half circle.

// _OverlapRegion mirrors this so both halves are done.

for (int dy = -ry; dy <= ry; ++dy) {

int dx = std::lround(sqrt(float(ry * ry - dy * dy)) * float(rx) / float(ry));

_OverlapRegion(m_pOutlineData->mWideOutline, m_pOutlineData->mOutline, dx, dy);

}

} else {

_OverlapRegion(m_pOutlineData->mWideOutline, m_pOutlineData->mOutline, rx, 0);

}

return true;

{

CAtlList<CEllipseCenterGroup> centerGroups;

std::vector<SpanEndPoint> wideSpanEndPoints;

wideSpanEndPoints.reserve(10);

m_pOutlineData->mWideOutline.reserve(m_pOutlineData->mOutline.size() + m_pOutlineData->mOutline.size() / 2);

auto flushLines = [&](int yStart, int yStop, tSpanBuffer & dst) {

for (int y = yStart; y < yStop; y++) {

POSITION pos = centerGroups.GetHeadPosition();

while (pos) {

POSITION curPos = pos;

auto& group = centerGroups.GetNext(pos);

group.FlushLine(y, wideSpanEndPoints);

if (group.IsEmpty()) {

centerGroups.RemoveAt(curPos);

}

}

if (!wideSpanEndPoints.empty()) {

ASSERT(wideSpanEndPoints.size() % 2 == 0);

std::sort(wideSpanEndPoints.begin(), wideSpanEndPoints.end());

for (auto it = wideSpanEndPoints.cbegin(); it != wideSpanEndPoints.cend(); ++it) {

int xLeft = it->x;

int count = 1;

do {

++it;

if (it->bEnd) {

count--;

} else {

count++;

}

} while (count > 0);

int xRight = it->x;

if (xLeft < xRight) {

dst.emplace_back(unsigned __int64(y) << 32 | xLeft, unsigned __int64(y) << 32 | xRight);

}

}

wideSpanEndPoints.clear();

}

}

};

int yPrec = unsigned int(m_pOutlineData->mOutline.front().first >> 32);

POSITION pos = centerGroups.GetHeadPosition();

for (const auto& span : m_pOutlineData->mOutline) {

int y = int(span.first >> 32);

int xLeft = int(span.first);

int xRight = int(span.second);

if (y != yPrec) {

flushLines(yPrec - ry, y - ry, m_pOutlineData->mWideOutline);

yPrec = y;

pos = centerGroups.GetHeadPosition();

}

while (pos) {

int position = centerGroups.GetAt(pos).GetRelativePosition(xLeft, y);

if (position == CEllipseCenterGroup::INSIDE) {

break;

} else if (position == CEllipseCenterGroup::BEFORE) {

pos = centerGroups.InsertBefore(pos, CEllipseCenterGroup(m_pEllipse));

break;

} else {

centerGroups.GetNext(pos);

}

}

if (!pos) {

pos = centerGroups.AddTail(CEllipseCenterGroup(m_pEllipse));

}

centerGroups.GetNext(pos).AddSpan(y, xLeft, xRight);

}

// Flush the remaining of the lines

flushLines(yPrec - ry, yPrec + ry + 1, m_pOutlineData->mWideOutline);

{

m_pOverlayData = std::make_shared<COverlayData>();

if (!m_pOutlineData || !m_pOutlineData->mWidth || !m_pOutlineData->mHeight) {

return true;

}

xsub &= 7;

ysub &= 7;

int width = m_pOutlineData->mWidth + xsub;

int height = m_pOutlineData->mHeight;// + ysub

m_pOverlayData->mOffsetX = m_pOutlineData->mPathOffsetX - xsub;

m_pOverlayData->mOffsetY = m_pOutlineData->mPathOffsetY - ysub;

m_pOutlineData->mWideBorder = (m_pOutlineData->mWideBorder + 7) & ~7;

if (!m_pOutlineData->mWideOutline.empty() || fBlur || fGaussianBlur > 0) {

int bluradjust = 0;

if (fGaussianBlur > 0) {

bluradjust += (int)(fGaussianBlur * 3 * 8 + 0.5) | 1;

}

if (fBlur) {

bluradjust += 8;

}

// Expand the buffer a bit when we're blurring, since that can also widen the borders a bit

bluradjust = (bluradjust + 7) & ~7;

width += 2 * m_pOutlineData->mWideBorder + bluradjust * 2;

height += 2 * m_pOutlineData->mWideBorder + bluradjust * 2;

xsub += m_pOutlineData->mWideBorder + bluradjust;

ysub += m_pOutlineData->mWideBorder + bluradjust;

m_pOverlayData->mOffsetX -= m_pOutlineData->mWideBorder + bluradjust;

m_pOverlayData->mOffsetY -= m_pOutlineData->mWideBorder + bluradjust;

}

m_pOverlayData->mOverlayWidth = ((width + 7) >> 3) + 1;

// fixed image height

m_pOverlayData->mOverlayHeight = ((height + 14) >> 3) + 1;

m_pOverlayData->mOverlayPitch = (m_pOverlayData->mOverlayWidth + 15) & ~15; // Round the next multiple of 16

m_pOverlayData->mpOverlayBufferBody = (byte*)_aligned_malloc(m_pOverlayData->mOverlayPitch * m_pOverlayData->mOverlayHeight, 16);

m_pOverlayData->mpOverlayBufferBorder = (byte*)_aligned_malloc(m_pOverlayData->mOverlayPitch * m_pOverlayData->mOverlayHeight, 16);

if (!m_pOverlayData->mpOverlayBufferBody || !m_pOverlayData->mpOverlayBufferBorder) {

m_pOverlayData = nullptr;

return false;

}

ZeroMemory(m_pOverlayData->mpOverlayBufferBody, m_pOverlayData->mOverlayPitch * m_pOverlayData->mOverlayHeight);

ZeroMemory(m_pOverlayData->mpOverlayBufferBorder, m_pOverlayData->mOverlayPitch * m_pOverlayData->mOverlayHeight);

// Are we doing a border?

const tSpanBuffer* pOutline[2] = { &m_pOutlineData->mOutline, &m_pOutlineData->mWideOutline };

for (ptrdiff_t i = _countof(pOutline) - 1; i >= 0; i--) {

auto it = pOutline[i]->cbegin();

auto itEnd = pOutline[i]->cend();

byte* buffer = (i == 0) ? m_pOverlayData->mpOverlayBufferBody : m_pOverlayData->mpOverlayBufferBorder;

for (; it != itEnd; ++it) {

unsigned __int64 f = (*it).first;

unsigned int y = (f >> 32) - 0x40000000 + ysub;

unsigned int x1 = (f & 0xffffffff) - 0x40000000 + xsub;

unsigned __int64 s = (*it).second;

unsigned int x2 = (s & 0xffffffff) - 0x40000000 + xsub;

if (x2 > x1) {

unsigned int first = x1 >> 3;

unsigned int last = (x2 - 1) >> 3;

byte* dst = buffer + m_pOverlayData->mOverlayPitch * (y >> 3) + first;

if (first == last) {

*dst += byte(x2 - x1);

} else {

*dst += byte(((first + 1) << 3) - x1);

++dst;

while (++first < last) {

*dst += 0x08;

++dst;

}

*dst += byte(x2 - (last << 3));

}

}

}

}

// Do some gaussian blur magic

if (fGaussianBlur > 0) {

GaussianKernel filter(fGaussianBlur);

if (m_pOverlayData->mOverlayWidth >= filter.width && m_pOverlayData->mOverlayHeight >= filter.width) {

size_t pitch = m_pOverlayData->mOverlayPitch;

byte* tmp = (byte*)_aligned_malloc(pitch * m_pOverlayData->mOverlayHeight * sizeof(byte), 16);

if (!tmp) {

return false;

}

byte* src = m_pOutlineData->mWideOutline.empty() ? m_pOverlayData->mpOverlayBufferBody : m_pOverlayData->mpOverlayBufferBorder;

#if defined(_M_IX86_FP) && _M_IX86_FP < 2

if (!m_bUseSSE2) {

SeparableFilterX<1>(src, tmp, m_pOverlayData->mOverlayWidth, m_pOverlayData->mOverlayHeight, pitch,

filter.kernel, filter.width, filter.divisor);

SeparableFilterY<1>(tmp, src, m_pOverlayData->mOverlayWidth, m_pOverlayData->mOverlayHeight, pitch,

filter.kernel, filter.width, filter.divisor);

} else

#endif

{

SeparableFilterX_SSE2(src, tmp, m_pOverlayData->mOverlayWidth, m_pOverlayData->mOverlayHeight, pitch,

filter.kernel, filter.width, filter.divisor);

SeparableFilterY_SSE2(tmp, src, m_pOverlayData->mOverlayWidth, m_pOverlayData->mOverlayHeight, pitch,

filter.kernel, filter.width, filter.divisor);

}

_aligned_free(tmp);

}

}

// If we're blurring, do a 3x3 box blur

// Can't do it on subpictures smaller than 3x3 pixels

for (int pass = 0; pass < fBlur; pass++) {

if (m_pOverlayData->mOverlayWidth >= 3 && m_pOverlayData->mOverlayHeight >= 3) {

int pitch = m_pOverlayData->mOverlayPitch;

byte* tmp = DEBUG_NEW byte[pitch * m_pOverlayData->mOverlayHeight];

if (!tmp) {

return false;

}

byte* buffer = m_pOutlineData->mWideOutline.empty() ? m_pOverlayData->mpOverlayBufferBody : m_pOverlayData->mpOverlayBufferBorder;

memcpy(tmp, buffer, pitch * m_pOverlayData->mOverlayHeight);

// This could be done in a separated way and win some speed

for (ptrdiff_t j = 1; j < m_pOverlayData->mOverlayHeight - 1; j++) {

byte* src = tmp + pitch * j + 1;

byte* dst = buffer + pitch * j + 1;

for (ptrdiff_t i = 1; i < m_pOverlayData->mOverlayWidth - 1; i++, src++, dst++) {

*dst = (src[-1 - pitch] + (src[-pitch] << 1) + src[+1 - pitch]

+ (src[-1] << 1) + (src[0] << 2) + (src[+1] << 1)

+ src[-1 + pitch] + (src[+pitch] << 1) + src[+1 + pitch]) >> 4;

}

}

delete [] tmp;

}

}

return true;

static __forceinline DWORD safe_subtract(DWORD a, DWORD b) {

return a > b ? a - b : 0;

}

static __forceinline void pix_mix(DWORD* dst, DWORD color, DWORD alpha) {

const int ROUNDING_ERR = 1 << (6 - 1);

DWORD a = (alpha * (color >> 24) + ROUNDING_ERR) >> 6;

DWORD ia = 256 - a;

a += 1;

*dst = ((((*dst & 0x00ff00ff) * ia + (color & 0x00ff00ff) * a) & 0xff00ff00) >> 8) |

((((*dst & 0x0000ff00) * ia + (color & 0x0000ff00) * a) & 0x00ff0000) >> 8) |

((((*dst >> 8) & 0x00ff0000) * ia) & 0xff000000);

}

static __forceinline void pix_mix(DWORD* dst, DWORD color, DWORD shapealpha, DWORD clipalpha) {

const int ROUNDING_ERR = 1 << (12 - 1);

DWORD a = (shapealpha * clipalpha * (color >> 24) + ROUNDING_ERR) >> 12;

DWORD ia = 256 - a;

a += 1;

*dst = ((((*dst & 0x00ff00ff) * ia + (color & 0x00ff00ff) * a) & 0xff00ff00) >> 8) |

((((*dst & 0x0000ff00) * ia + (color & 0x0000ff00) * a) & 0x00ff0000) >> 8) |

((((*dst >> 8) & 0x00ff0000) * ia) & 0xff000000);

}

template <typename... Args>

static __forceinline void pix_mix_row(BYTE* __restrict dst, const BYTE* __restrict alpha, int w, DWORD color,

Args... args) {

DWORD* __restrict dst_w = reinterpret_cast<DWORD* __restrict>(dst);

for (int wt = 0; wt < w; ++wt) {

pix_mix(&dst_w[wt], color, alpha[wt], args[wt]...);

}

}

template <typename... Args>

static __forceinline void pix_mix_row(BYTE* __restrict dst, const BYTE alpha, int w, DWORD color, Args... args) {

DWORD* __restrict dst_w = reinterpret_cast<DWORD* __restrict>(dst);

for (int wt = 0; wt < w; ++wt) {

pix_mix(&dst_w[wt], color, alpha, args[wt]...);

}

}

static __forceinline void pix_mix(DWORD* __restrict dst, DWORD color, DWORD border, DWORD, DWORD body) {

pix_mix(dst, color, safe_subtract(border, body));

}

static __forceinline void pix_mix(DWORD* __restrict dst, DWORD color, DWORD border, DWORD, DWORD body,

DWORD clipalpha) {

pix_mix(dst, color, safe_subtract(border, body), clipalpha);

}