: org(CSize(0, 0))

, lpTemp1(nullptr)

, lpTemp2(nullptr)

, nPlane(0)

, bCustomPal(false)

, bAligned(true)

, tridx(0)

, orgpal(nullptr)

, cuspal(nullptr)

, nLang(SIZE_T_ERROR)

, nIdx(SIZE_T_ERROR)

, bForced(false)

, bAnimated(false)

, tCurrent(-1)

, start(0)

, delay(0)

, rect(CRect(0, 0, 0, 0))

, lpPixels(nullptr)

{

ZeroMemory(&pal, sizeof(pal));

{

// if there is nothing to crop TrimSubImage might even add a 1 pixel

// wide border around the text, that's why we need a bit more memory

// to be allocated.

if (lpTemp1 == nullptr || w * h > org.cx * org.cy || (w + 2) * (h + 2) > (org.cx + 2) * (org.cy + 2)) {

Free();

try {

lpTemp1 = DEBUG_NEW RGBQUAD[w * h];

} catch (CMemoryException* e) {

ASSERT(FALSE);

e->Delete();

return false;

}

try {

lpTemp2 = DEBUG_NEW RGBQUAD[(w + 2) * (h + 2)];

} catch (CMemoryException* e) {

ASSERT(FALSE);

e->Delete();

delete [] lpTemp1;

lpTemp1 = nullptr;

return false;

}

org.cx = w;

org.cy = h;

}

lpPixels = lpTemp1;

return true;

{

SAFE_DELETE_ARRAY(lpTemp1);

SAFE_DELETE_ARRAY(lpTemp2);

lpPixels = nullptr;

bool _bCustomPal,

int _tridx,

RGBQUAD* _orgpal /*[16]*/, RGBQUAD* _cuspal /*[4]*/,

bool _bTrim)

{

GetPacketInfo(_lpData, _packetSize, _dataSize, _t);

if (!Alloc(rect.Width(), rect.Height())) {

return false;

}

lpPixels = lpTemp1;

nPlane = 0;

bAligned = true;

bCustomPal = _bCustomPal;

orgpal = _orgpal;

tridx = _tridx;

cuspal = _cuspal;

CPoint p = rect.TopLeft();

size_t end[] = { nOffset[1], _dataSize };

while (nOffset[nPlane] < end[nPlane]) {

DWORD code;

if ((code = GetNibble(_lpData)) >= 0x4

|| (code = (code << 4) | GetNibble(_lpData)) >= 0x10

|| (code = (code << 4) | GetNibble(_lpData)) >= 0x40

|| (code = (code << 4) | GetNibble(_lpData)) >= 0x100) {

DrawPixels(p, code >> 2, code & 3);

if ((p.x += code >> 2) < rect.right) {

continue;

}

}

DrawPixels(p, rect.right - p.x, code & 3);

if (!bAligned) {

GetNibble(_lpData); // align to byte

}

p.x = rect.left;

p.y++;

nPlane = 1 - nPlane;

}

rect.bottom = std::min(p.y, rect.bottom);

if (_bTrim) {

TrimSubImage();

}

return true;

{

// delay = 0;

size_t i, nextctrlblk = dataSize;

WORD _pal = 0, tr = 0;

WORD nPal = 0, nTr = 0;

do {

i = nextctrlblk;

tCurrent = 1024 * ((lpData[i] << 8) | lpData[i + 1]) / 90;

i += 2;

nextctrlblk = (lpData[i] << 8) | lpData[i + 1];

i += 2;

if (nextctrlblk > packetSize || nextctrlblk < dataSize) {

ASSERT(0);

return;

}

if (tCurrent > t) {

break;

}

bool bBreak = false;

while (!bBreak) {

size_t len = 0;

switch (lpData[i]) {

case 0x00:

len = 0;

break;

case 0x01:

len = 0;

break;

case 0x02:

len = 0;

break;

case 0x03:

len = 2;

break;

case 0x04:

len = 2;

break;

case 0x05:

len = 6;

break;

case 0x06:

len = 4;

break;

default:

len = 0;

break;

}

if (i + len >= packetSize) {

TRACE(_T("Warning: Wrong subpicture parameter block ending\n"));

break;

}

switch (lpData[i++]) {

case 0x00: // forced start displaying

bForced = true;

break;

case 0x01: // start displaying

bForced = false;

break;

case 0x02: // stop displaying

delay = tCurrent;

break;

case 0x03:

_pal = (lpData[i] << 8) | lpData[i + 1];

i += 2;

nPal++;

break;

case 0x04:

tr = (lpData[i] << 8) | lpData[i + 1];

i += 2;

nTr++;

//tr &= 0x00f0;

break;

case 0x05:

rect = CRect((lpData[i] << 4) + (lpData[i + 1] >> 4),

(lpData[i + 3] << 4) + (lpData[i + 4] >> 4),

((lpData[i + 1] & 0x0f) << 8) + lpData[i + 2] + 1,

((lpData[i + 4] & 0x0f) << 8) + lpData[i + 5] + 1);

i += 6;

break;

case 0x06:

nOffset[0] = (lpData[i] << 8) + lpData[i + 1];

i += 2;

nOffset[1] = (lpData[i] << 8) + lpData[i + 1];

i += 2;

break;

case 0xff: // end of ctrlblk

bBreak = true;

continue;

default: // skip this ctrlblk

bBreak = true;

break;

}

}

} while (i <= nextctrlblk && i < packetSize);

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

this->pal[i].pal = (_pal >> (i << 2)) & 0xf;

this->pal[i].tr = (tr >> (i << 2)) & 0xf;

}

bAnimated = (nPal > 1 || nTr > 1);

{

size_t& off = nOffset[nPlane];

BYTE ret = lpData[off];

if (bAligned) {

ret >>= 4;

}

ret &= 0x0f;

bAligned = !bAligned;

if (bAligned) {

off++;

}

return ret;

{

if (length <= 0

|| p.x + length < rect.left

|| p.x >= rect.right

|| p.y < rect.top

|| p.y >= rect.bottom) {

return;

}

if (p.x < rect.left) {

p.x = rect.left;

}

if (p.x + length >= rect.right) {

length = rect.right - p.x;

}

RGBQUAD* ptr = &lpPixels[rect.Width() * (p.y - rect.top) + (p.x - rect.left)];

RGBQUAD c;

if (!bCustomPal) {

c = orgpal[pal[colorId].pal];

c.rgbReserved = (pal[colorId].tr << 4) | pal[colorId].tr;

} else {

c = cuspal[colorId];

}

while (length-- > 0) {

*ptr++ = c;

}

{

CRect r;

r.left = rect.Width();

r.top = rect.Height();

r.right = 0;

r.bottom = 0;

RGBQUAD* ptr = lpTemp1;

for (int j = 0, y = rect.Height(); j < y; j++) {

for (int i = 0, x = rect.Width(); i < x; i++, ptr++) {

if (ptr->rgbReserved) {

if (r.top > j) {

r.top = j;

}

if (r.bottom < j) {

r.bottom = j;

}

if (r.left > i) {

r.left = i;

}

if (r.right < i) {

r.right = i;

}

}

}

}

if (r.left > r.right || r.top > r.bottom) {

return;

}

r += CRect(0, 0, 1, 1);

r &= CRect(CPoint(0, 0), rect.Size());

int w = r.Width(), h = r.Height();

DWORD offset = r.top * rect.Width() + r.left;

r += CRect(1, 1, 1, 1);

DWORD* src = (DWORD*)&lpTemp1[offset];

DWORD* dst = (DWORD*)&lpTemp2[1 + w + 1];

ZeroMemory(lpTemp2, (1 + w + 1)*sizeof(RGBQUAD));

for (int height = h; height; height--, src += rect.Width()) {

*dst++ = 0;

memcpy(dst, src, w * sizeof(RGBQUAD));

dst += w;

*dst++ = 0;

}

ZeroMemory(dst, (1 + w + 1)*sizeof(RGBQUAD));

lpPixels = lpTemp2;

rect = r + rect.TopLeft();

{

int len = (int)o.pa.GetCount();

if (len < 7) {

return false; // small segments should be handled with beziers...

}

for (start = 0; start < len && !o.da[start]; start++) {

;

}

for (end = len - 1; end > start && !o.da[end]; end--) {

;

}

if (end - start < 8 || end - start < (len - end) + (start - 0)) {

return false;

}

CUIntArray la, ra;

UINT i, j, k;

for (i = start + 1, j = end, k = start; i <= j; i++) {

if (!o.da[i]) {

continue;

}

if (o.da[i] == o.da[k]) {

return false;

}

if (o.da[i] == -1) {

la.Add(i - k);

} else {

ra.Add(i - k);

}

k = i;

}

bool fl = true, fr = true;

// these tests are completly heuristic and might be redundant a bit...

for (i = 0, j = (UINT)la.GetSize(); i < j && fl; i++) {

if (la[i] != 1) {

fl = false;

}

}

for (i = 0, j = (UINT)ra.GetSize(); i < j && fr; i++) {

if (ra[i] != 1) {

fr = false;

}

}

if (!fl && !fr) {

return false; // can't be a line if there are bigger steps than one in both directions (lines are usually drawn by stepping one either horizontally or vertically)

}

if (fl && fr && 1.0 * (end - start) / ((len - end) * 2 + (start - 0) * 2) > 0.4) {

return false; // if this section is relatively too small it may only be a rounded corner

}

if (!fl && !la.IsEmpty() && la.GetSize() <= 4 && (la[0] == 1 && la[la.GetSize() - 1] == 1)) {

return false; // one step at both ends, doesn't sound good for a line (may be it was skewed, so only eliminate smaller sections where beziers going to look just as good)

}

if (!fr && !ra.IsEmpty() && ra.GetSize() <= 4 && (ra[0] == 1 && ra[ra.GetSize() - 1] == 1)) {

return false; // -''-

}

CUIntArray& a = !fl ? la : ra;

len = (int)a.GetSize();

int sum = 0;

for (i = 0, j = INT_MAX, k = 0; i < (UINT)len; i++) {

if (j > a[i]) {

j = a[i];

}

if (k < a[i]) {

k = a[i];

}

sum += a[i];

}

if (k - j > 2 && 1.0 * sum / len < 2) {

return false;

}

if (k - j > 2 && 1.0 * sum / len >= 2 && len < 4) {

return false;

}

if ((la.GetSize() / 2 + ra.GetSize() / 2) / 2 <= 2) {

if ((k + j) / 2 < 2 && k * j != 1) {

return false;

}

}

double err = 0;

CPoint sp = o.pa[start], ep = o.pa[end];

double minerr = 0, maxerr = 0;

double vx = ep.x - sp.x, vy = ep.y - sp.y, l = sqrt(vx * vx + vy * vy);

vx /= l;

vy /= l;

for (i = start + 1, j = end - 1; i <= j; i++) {

CPoint p = o.pa[i], dp = p - sp;

double t = vx * dp.x + vy * dp.y, dx = vx * t + sp.x - p.x, dy = vy * t + sp.y - p.y;

t = dx * dx + dy * dy;

err += t;

t = sqrt(t);

if (vy * dx - dy * vx < 0) {

if (minerr > -t) {

minerr = -t;

}

} else {

if (maxerr < t) {

maxerr = t;

}

}

}

return ((maxerr - minerr) / l < 0.1 || err / l < 1.5 || (fabs(maxerr) < 8 && fabs(minerr) < 8));

{

size_t len2 = o.da.GetCount();

CUIntArray la;

for (size_t i = 0, j = 0; j < len2; j++) {

if (j + 1 == len2 || o.da[j]) {

la.Add(UINT(j - i));

i = j;

}

}

ptrdiff_t len = la.GetCount();

int ret = 0;

// check if we can find a reason to add a penalty degree, or two :P

// it is mainly about looking for distant corners

{

int penalty = 0;

int ma[2] = {0, 0};

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

ma[i & 1] += la[i];

}

int ca[2] = {ma[0], ma[1]};

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

ca[i & 1] -= la[i];

double c1 = 1.0 * ca[0] / ma[0], c2 = 1.0 * ca[1] / ma[1], c3 = 1.0 * la[i] / ma[i & 1];

if (len2 > 16 && (fabs(c1 - c2) > 0.7 || (c3 > 0.6 && la[i] > 5))) {

penalty = 2;

break;

}

if (fabs(c1 - c2) > 0.6 || (c3 > 0.4 && la[i] > 5)) {

penalty = 1;

}

}

ret += penalty;

}

la[0] <<= 1;

la[len - 1] <<= 1;

for (ptrdiff_t i = 0; i < len; i += 2) {

if (la[i] > 1) {

ret++; // prependicular to the last chosen section and bigger then 1 -> add a degree and continue with the other dir

i--;

}

}

return ret;

{

CAtlArray<CPoint>& pa = o.pa;

int len = (int)pa.GetCount();

if (len < 6) {

return false;

}

mincf = 1;

maxcf = -1;

CPoint p = pa[len - 1] - pa[0];

double l = vectlen(p);

UNREFERENCED_PARAMETER(l);

for (ptrdiff_t i = 2; i < len - 2; i++) { // skip the endpoints, they aren't accurate

CPoint p1 = pa[0] - pa[i], p2 = pa[len - 1] - pa[i];

double l1 = vectlen(p1), l2 = vectlen(p2);

int sign = p1.x * p.y - p1.y * p.x >= 0 ? 1 : -1;

double c = (1.0 * len / 2 - fabs(i - 1.0 * len / 2)) / len * 2; // c: 0 -> 1 -> 0

double cosfi = (1 + (p1.x * p2.x + p1.y * p2.y) / (l1 * l2)) * sign * c;

if (mincf > cosfi) {

mincf = cosfi;

}

if (maxcf < cosfi) {

maxcf = cosfi;

}

}

return true;

{

int i;

CAtlArray<CPoint>& pa = o.pa;

int len = (int)pa.GetCount();

if (len <= 1) {

return false;

} else if (len == 2) {

CPoint mid = pa[0] + pa[1];

mid.x >>= 1;

mid.y >>= 1;

p1 = p2 = mid;

return true;

}

CPoint dir1 = pa[1] - pa[0], dir2 = pa[len - 2] - pa[len - 1];

if ((dir1.x && dir1.y) || (dir2.x && dir2.y)) {

return false; // we are only fitting beziers with hor./ver. endings

}

if (CalcPossibleCurveDegree(o) > 3) {

return false;

}

double mincf, maxcf;

if (MinMaxCosfi(o, mincf, maxcf)) {

if (maxcf - mincf > 0.8

|| maxcf - mincf > 0.6 && (maxcf >= 0.4 || mincf <= -0.4)) {

return false;

}

}

CPoint p0 = p1 = pa[0];

CPoint p3 = p2 = pa[len - 1];

CAtlArray<double> pl;

pl.SetCount(len);

double c10 = 0, c11 = 0, c12 = 0, c13 = 0, c1x = 0, c1y = 0;

double c20 = 0, c21 = 0, c22 = 0, c23 = 0, c2x = 0, c2y = 0;

double length = 0;

for (pl[0] = 0, i = 1; i < len; i++) {

CPoint diff = (pa[i] - pa[i - 1]);

pl[i] = (length += sqrt((double)(diff.x * diff.x + diff.y * diff.y)));

}

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

double t1 = pl[i] / length;

double t2 = t1 * t1;

double t3 = t2 * t1;

double it1 = 1 - t1;

double it2 = it1 * it1;

double it3 = it2 * it1;

double dc1 = 3.0 * it2 * t1;

double dc2 = 3.0 * it1 * t2;

c10 += it3 * dc1;

c11 += dc1 * dc1;

c12 += dc2 * dc1;

c13 += t3 * dc1;

c1x += pa[i].x * dc1;

c1y += pa[i].y * dc1;

c20 += it3 * dc2;

c21 += dc1 * dc2;

c22 += dc2 * dc2;

c23 += t3 * dc2;

c2x += pa[i].x * dc2;

c2y += pa[i].y * dc2;

}

if (dir1.y == 0 && dir2.x == 0) {

p1.x = (int)((c1x - c10 * p0.x - c12 * p3.x - c13 * p3.x) / c11 + 0.5);

p2.y = (int)((c2y - c20 * p0.y - c21 * p0.y - c23 * p3.y) / c22 + 0.5);

} else if (dir1.x == 0 && dir2.y == 0) {

p2.x = (int)((c2x - c20 * p0.x - c21 * p0.x - c23 * p3.x) / c22 + 0.5);

p1.y = (int)((c1y - c10 * p0.y - c12 * p3.y - c13 * p3.y) / c11 + 0.5);

} else if (dir1.y == 0 && dir2.y == 0) {

// cramer's rule

double D = c11 * c22 - c12 * c21;

p1.x = (int)(((c1x - c10 * p0.x - c13 * p3.x) * c22 - c12 * (c2x - c20 * p0.x - c23 * p3.x)) / D + 0.5);

p2.x = (int)((c11 * (c2x - c20 * p0.x - c23 * p3.x) - (c1x - c10 * p0.x - c13 * p3.x) * c21) / D + 0.5);

} else if (dir1.x == 0 && dir2.x == 0) {

// cramer's rule

double D = c11 * c22 - c12 * c21;

p1.y = (int)(((c1y - c10 * p0.y - c13 * p3.y) * c22 - c12 * (c2y - c20 * p0.y - c23 * p3.y)) / D + 0.5);

p2.y = (int)((c11 * (c2y - c20 * p0.y - c23 * p3.y) - (c1y - c10 * p0.y - c13 * p3.y) * c21) / D + 0.5);

} else { // must not happen

ASSERT(0);

return false;

}

// check for "inside-out" beziers

CPoint dir3 = p1 - p0, dir4 = p2 - p3;

if ((dir1.x * dir3.x + dir1.y * dir3.y) <= 0 || (dir2.x * dir4.x + dir2.y * dir4.y) <= 0) {

return false;

}

return true;

{

ret.RemoveAll();

int len = int(o.pa.GetCount());

int cur = (_start) % len, first = -1, last = -1;

int lastDir = 0;

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

cur = (cur + 1) % len;

if (o.da[cur] == 0) {

continue;

}

if (first == -1) {

first = cur;

}

if (lastDir == o.da[cur]) {

CPoint startp = o.pa[first] + o.pa[_start];

startp.x >>= 1;

startp.y >>= 1;

CPoint endp = o.pa[last] + o.pa[cur];

endp.x >>= 1;

endp.y >>= 1;

if (first < _start) {

first += len;

}

_start = ((_start + first) >> 1) + 1;

if (_start >= len) {

_start -= len;

}

if (cur < last) {

cur += len;

}

cur = ((last + cur + 1) >> 1);

if (cur >= len) {

cur -= len;

}

ret.Add(startp, 0);

while (_start != cur) {

ret.Add(o.pa[_start], o.da[_start]);

_start++;

if (_start >= len) {

_start -= len;

}

}

ret.Add(endp, 0);

return last;

}

lastDir = o.da[cur];

last = cur;

}

ASSERT(0);

return _start;

{

size_t len = o.pa.GetCount();

if (len < 4) {

return;

}

CAtlArray<UINT> la, sa, ea;

size_t i, j, k;

for (i = 0, j = 0; j < len; j++) {

if (j + 1 == len || o.da[j]) {

la.Add(unsigned int(j - i));

sa.Add(unsigned int(i));

ea.Add(unsigned int(j));

i = j;

}

}

size_t maxlen = 0, maxidx = SIZE_T_ERROR;

size_t maxlen2 = 0, maxidx2 = SIZE_T_ERROR;

for (i = 0; i < la.GetCount(); i++) {

if (maxlen < la[i]) {

maxlen = la[i];

maxidx = i;

}