开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Rasterizer.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：22k
源码类别：

多媒体编程

开发平台：

Visual C++

Rasterizer.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 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.  */
  22. #include "stdafx.h"
  23. #include <string.h>
  24. #include <math.h>
  25. #include <vector>
  26. #include <algorithm>
  27. #include "Rasterizer.h"
  29. Rasterizer::Rasterizer() : mpPathTypes(NULL), mpPathPoints(NULL), mPathPoints(0), mpOverlayBuffer(NULL)
  30. {
  31. mOverlayWidth = mOverlayHeight = 0;
  32. mPathOffsetX = mPathOffsetY = 0;
  33. mOffsetX = mOffsetY = 0;
  34. }
  36. Rasterizer::~Rasterizer()
  37. {
  38. _TrashPath();
  39. _TrashOverlay();
  40. }
  42. void Rasterizer::_TrashPath()
  43. {
  44. delete [] mpPathTypes;
  45. delete [] mpPathPoints;
  46. mpPathTypes = NULL;
  47. mpPathPoints = NULL;
  48. mPathPoints = 0;
  49. }
  51. void Rasterizer::_TrashOverlay()
  52. {
  53. delete [] mpOverlayBuffer;
  54. mpOverlayBuffer = NULL;
  55. }
  57. void Rasterizer::_ReallocEdgeBuffer(int edges)
  58. {
  59. mEdgeHeapSize = edges;
  60. mpEdgeBuffer = (Edge*)realloc(mpEdgeBuffer, sizeof(Edge)*edges);
  61. }
  63. void Rasterizer::_EvaluateBezier(int ptbase, bool fBSpline)
  64. {
  65. const POINT* pt0 = mpPathPoints + ptbase;
  66. const POINT* pt1 = mpPathPoints + ptbase + 1;
  67. const POINT* pt2 = mpPathPoints + ptbase + 2;
  68. const POINT* pt3 = mpPathPoints + ptbase + 3;
  70. double x0 = pt0->x;
  71. double x1 = pt1->x;
  72. double x2 = pt2->x;
  73. double x3 = pt3->x;
  74. double y0 = pt0->y;
  75. double y1 = pt1->y;
  76. double y2 = pt2->y;
  77. double y3 = pt3->y;
  79. double cx3, cx2, cx1, cx0, cy3, cy2, cy1, cy0;
  81. if(fBSpline)
  82. {
  83. // 1   [-1 +3 -3 +1]
  84. // - * [+3 -6 +3  0]
  85. // 6   [-3  0 +3  0]
  86. //    [+1 +4 +1  0]
  88. double _1div6 = 1.0/6.0;
  90. cx3 = _1div6*(-  x0+3*x1-3*x2+x3);
  91. cx2 = _1div6*( 3*x0-6*x1+3*x2);
  92. cx1 = _1div6*(-3*x0    +3*x2);
  93. cx0 = _1div6*(   x0+4*x1+1*x2);
  95. cy3 = _1div6*(-  y0+3*y1-3*y2+y3);
  96. cy2 = _1div6*( 3*y0-6*y1+3*y2);
  97. cy1 = _1div6*(-3*y0     +3*y2);
  98. cy0 = _1div6*(   y0+4*y1+1*y2);
  99. }
  100. else // bezier
  101. {
  102. // [-1 +3 -3 +1]
  103. // [+3 -6 +3  0]
  104. // [-3 +3  0  0]
  105. // [+1  0  0  0]
  107. cx3 = -  x0+3*x1-3*x2+x3;
  108. cx2 =  3*x0-6*x1+3*x2;
  109. cx1 = -3*x0+3*x1;
  110. cx0 =    x0;
  112. cy3 = -  y0+3*y1-3*y2+y3;
  113. cy2 =  3*y0-6*y1+3*y2;
  114. cy1 = -3*y0+3*y1;
  115. cy0 =    y0;
  116. }
  118. //
  119. // This equation is from Graphics Gems I.
  120. //
  121. // The idea is that since we're approximating a cubic curve with lines,
  122. // any error we incur is due to the curvature of the line, which we can
  123. // estimate by calculating the maximum acceleration of the curve.  For
  124. // a cubic, the acceleration (second derivative) is a line, meaning that
  125. // the absolute maximum acceleration must occur at either the beginning
  126. // (|c2|) or the end (|c2+c3|).  Our bounds here are a little more
  127. // conservative than that, but that's okay.
  128. //
  129. // If the acceleration of the parametric formula is zero (c2 = c3 = 0),
  130. // that component of the curve is linear and does not incur any error.
  131. // If a=0 for both X and Y, the curve is a line segment and we can
  132. // use a step size of 1.
  134. double maxaccel1 = fabs(2*cy2) + fabs(6*cy3);
  135. double maxaccel2 = fabs(2*cx2) + fabs(6*cx3);
  137. double maxaccel = maxaccel1 > maxaccel2 ? maxaccel1 : maxaccel2;
  138. double h = 1.0;
  140. if(maxaccel > 8.0) h = sqrt(8.0 / maxaccel);
  142. if(!fFirstSet) {firstp.x = (LONG)cx0; firstp.y = (LONG)cy0; lastp = firstp; fFirstSet = true;}
  144. for(double t = 0; t < 1.0; t += h)
  145. {
  146. double x = cx0 + t*(cx1 + t*(cx2 + t*cx3));
  147. double y = cy0 + t*(cy1 + t*(cy2 + t*cy3));
  148. _EvaluateLine(lastp.x, lastp.y, (int)x, (int)y);
  149. }
  151. double x = cx0 + cx1 + cx2 + cx3;
  152. double y = cy0 + cy1 + cy2 + cy3;
  153. _EvaluateLine(lastp.x, lastp.y, (int)x, (int)y);
  154. }
  156. void Rasterizer::_EvaluateLine(int pt1idx, int pt2idx)
  157. {
  158. const POINT* pt1 = mpPathPoints + pt1idx;
  159. const POINT* pt2 = mpPathPoints + pt2idx;
  161. _EvaluateLine(pt1->x, pt1->y, pt2->x, pt2->y);
  162. }
  164. void Rasterizer::_EvaluateLine(int x0, int y0, int x1, int y1)
  165. {
  166. if(lastp.x != x0 || lastp.y != y0)
  167. {
  168. _EvaluateLine(lastp.x, lastp.y, x0, y0);
  169. }
  171. if(!fFirstSet) {firstp.x = x0; firstp.y = y0; fFirstSet = true;}
  172. lastp.x = x1; lastp.y = y1;
  174. if(y1 > y0) // down
  175. {
  176. __int64 xacc = (__int64)x0 << 13;
  178. // prestep y0 down
  180. int dy = y1 - y0;
  181. int y = ((y0 + 3)&~7) + 4;
  182. int iy = y >> 3;
  184. y1 = (y1 - 5) >> 3;
  186. if(iy <= y1)
  187. {
  188. __int64 invslope = (__int64(x1 - x0) << 16) / dy;
  190. while(mEdgeNext + y1 + 1 - iy > mEdgeHeapSize)
  191. _ReallocEdgeBuffer(mEdgeHeapSize*2);
  193. xacc += (invslope * (y - y0)) >> 3;
  195. while(iy <= y1)
  196. {
  197. int ix = (int)((xacc + 32768) >> 16);
  199. mpEdgeBuffer[mEdgeNext].next = mpScanBuffer[iy];
  200. mpEdgeBuffer[mEdgeNext].posandflag = ix*2 + 1;
  202. mpScanBuffer[iy] = mEdgeNext++;
  204. ++iy;
  205. xacc += invslope;
  206. }
  207. }
  208. }
  209. else if(y1 < y0) // up
  210. {
  211. __int64 xacc = (__int64)x1 << 13;
  213. // prestep y1 down
  215. int dy = y0 - y1;
  216. int y = ((y1 + 3)&~7) + 4;
  217. int iy = y >> 3;
  219. y0 = (y0 - 5) >> 3;
  221. if(iy <= y0)
  222. {
  223. __int64 invslope = (__int64(x0 - x1) << 16) / dy;
  225. while(mEdgeNext + y0 + 1 - iy > mEdgeHeapSize)
  226. _ReallocEdgeBuffer(mEdgeHeapSize*2);
  228. xacc += (invslope * (y - y1)) >> 3;
  230. while(iy <= y0)
  231. {
  232. int ix = (int)((xacc + 32768) >> 16);
  234. mpEdgeBuffer[mEdgeNext].next = mpScanBuffer[iy];
  235. mpEdgeBuffer[mEdgeNext].posandflag = ix*2;
  237. mpScanBuffer[iy] = mEdgeNext++;
  239. ++iy;
  240. xacc += invslope;
  241. }
  242. }
  243. }
  244. }
  246. bool Rasterizer::BeginPath(HDC hdc)
  247. {
  248. _TrashPath();
  250. return !!::BeginPath(hdc);
  251. }
  253. bool Rasterizer::EndPath(HDC hdc)
  254. {
  255. ::CloseFigure(hdc);
  257. if(::EndPath(hdc))
  258. {
  259. mPathPoints = GetPath(hdc, NULL, NULL, 0);
  261. if(!mPathPoints)
  262. return true;
  264. mpPathTypes = (BYTE*)malloc(sizeof(BYTE) * mPathPoints);
  265. mpPathPoints = (POINT*)malloc(sizeof(POINT) * mPathPoints);
  267. if(mPathPoints == GetPath(hdc, mpPathPoints, mpPathTypes, mPathPoints))
  268. return true;
  269. }
  271. ::AbortPath(hdc);
  273. return false;
  274. }
  276. bool Rasterizer::PartialBeginPath(HDC hdc, bool bClearPath)
  277. {
  278. if(bClearPath)
  279. _TrashPath();
  281. return !!::BeginPath(hdc);
  282. }
  284. bool Rasterizer::PartialEndPath(HDC hdc, long dx, long dy)
  285. {
  286. ::CloseFigure(hdc);
  288. if(::EndPath(hdc))
  289. {
  290. int nPoints;
  291. BYTE* pNewTypes;
  292. POINT* pNewPoints;
  294. nPoints = GetPath(hdc, NULL, NULL, 0);
  296. if(!nPoints)
  297. return true;
  299. pNewTypes = (BYTE*)realloc(mpPathTypes, (mPathPoints + nPoints) * sizeof(BYTE));
  300. pNewPoints = (POINT*)realloc(mpPathPoints, (mPathPoints + nPoints) * sizeof(POINT));
  302. if(pNewTypes)
  303. mpPathTypes = pNewTypes;
  305. if(pNewPoints)
  306. mpPathPoints = pNewPoints;
  308. BYTE* pTypes = new BYTE[nPoints];
  309. POINT* pPoints = new POINT[nPoints];
  311. if(pNewTypes && pNewPoints && nPoints == GetPath(hdc, pPoints, pTypes, nPoints))
  312. {
  313. for(int i = 0; i < nPoints; ++i)
  314. {
  315. mpPathPoints[mPathPoints + i].x = pPoints[i].x + dx;
  316. mpPathPoints[mPathPoints + i].y = pPoints[i].y + dy;
  317. mpPathTypes[mPathPoints + i] = pTypes[i];
  318. }
  320. mPathPoints += nPoints;
  322. delete[] pTypes;
  323. delete[] pPoints;
  324. return true;
  325. }
  326. else
  327. DebugBreak();
  329. delete[] pTypes;
  330. delete[] pPoints;
  331. }
  333. ::AbortPath(hdc);
  335. return false;
  336. }
  338. bool Rasterizer::ScanConvert()
  339. {
  340. int lastmoveto = -1;
  341. int i;
  343. // Drop any outlines we may have.
  345. mOutline.clear();
  346. mWideOutline.clear();
  348. // Determine bounding box
  350. if(!mPathPoints)
  351. {
  352. mPathOffsetX = mPathOffsetY = 0;
  353. mWidth = mHeight = 0;
  354. return 0;
  355. }
  357. int minx = INT_MAX;
  358. int miny = INT_MAX;
  359. int maxx = INT_MIN;
  360. int maxy = INT_MIN;
  362. for(i=0; i<mPathPoints; ++i)
  363. {
  364. int ix = mpPathPoints[i].x;
  365. int iy = mpPathPoints[i].y;
  367. if(ix < minx) minx = ix;
  368. if(ix > maxx) maxx = ix;
  369. if(iy < miny) miny = iy;
  370. if(iy > maxy) maxy = iy;
  371. }
  373. minx = (minx >> 3) & ~7;
  374. miny = (miny >> 3) & ~7;
  375. maxx = (maxx + 7) >> 3;
  376. maxy = (maxy + 7) >> 3;
  378. for(i=0; i<mPathPoints; ++i)
  379. {
  380. mpPathPoints[i].x -= minx*8;
  381. mpPathPoints[i].y -= miny*8;
  382. }
  384. if(minx > maxx || miny > maxy)
  385. {
  386. mWidth = mHeight = 0;
  387. mPathOffsetX = mPathOffsetY = 0;
  388. _TrashPath();
  389. return true;
  390. }
  392. mWidth = maxx + 1 - minx;
  393. mHeight = maxy + 1 - miny;
  395. mPathOffsetX = minx;
  396. mPathOffsetY = miny;
  398. // Initialize edge buffer.  We use edge 0 as a sentinel.
  400. mEdgeNext = 1;
  401. mEdgeHeapSize = 2048;
  402. mpEdgeBuffer = (Edge*)malloc(sizeof(Edge)*mEdgeHeapSize);
  404. // Initialize scanline list.
  406. mpScanBuffer = new unsigned int[mHeight];
  407. memset(mpScanBuffer, 0, mHeight*sizeof(unsigned int));
  409. // Scan convert the outline.  Yuck, Bezier curves....
  411. // Unfortunately, Windows 95/98 GDI has a bad habit of giving us text
  412. // paths with all but the first figure left open, so we can't rely
  413. // on the PT_CLOSEFIGURE flag being used appropriately.
  415. fFirstSet = false;
  416. firstp.x = firstp.y = 0;
  417. lastp.x = lastp.y = 0;
  419. for(i=0; i<mPathPoints; ++i)
  420. {
  421. BYTE t = mpPathTypes[i] & ~PT_CLOSEFIGURE;
  423. switch(t)
  424. {
  425. case PT_MOVETO:
  426. if(lastmoveto >= 0 && firstp != lastp)
  427. _EvaluateLine(lastp.x, lastp.y, firstp.x, firstp.y);
  428. lastmoveto = i;
  429. fFirstSet = false;
  430. lastp = mpPathPoints[i];
  431. break;
  432. case PT_MOVETONC:
  433. break;
  434. case PT_LINETO:
  435. if(mPathPoints - (i-1) >= 2) _EvaluateLine(i-1, i);
  436. break;
  437. case PT_BEZIERTO:
  438. if(mPathPoints - (i-1) >= 4) _EvaluateBezier(i-1, false);
  439. i += 2;
  440. break;
  441. case PT_BSPLINETO:
  442. if(mPathPoints - (i-1) >= 4) _EvaluateBezier(i-1, true);
  443. i += 2;
  444. break;
  445. case PT_BSPLINEPATCHTO:
  446. if(mPathPoints - (i-3) >= 4) _EvaluateBezier(i-3, true);
  447. break;
  448. }
  449. }
  451. if(lastmoveto >= 0 && firstp != lastp)
  452. _EvaluateLine(lastp.x, lastp.y, firstp.x, firstp.y);
  454. // Free the path since we don't need it anymore.
  456. _TrashPath();
  458. // Convert the edges to spans.  We couldn't do this before because some of
  459. // the regions may have winding numbers >+1 and it would have been a pain
  460. // to try to adjust the spans on the fly.  We use one heap to detangle
  461. // a scanline's worth of edges from the singly-linked lists, and another
  462. // to collect the actual scans.
  464. std::vector<int> heap;
  466. mOutline.reserve(mEdgeNext / 2);
  468. __int64 y = 0;
  470. for(y=0; y<mHeight; ++y)
  471. {
  472. int count = 0;
  474. // Detangle scanline into edge heap.
  476. for(unsigned ptr = (unsigned)(mpScanBuffer[y]&0xffffffff); ptr; ptr = mpEdgeBuffer[ptr].next)
  477. {
  478. heap.push_back(mpEdgeBuffer[ptr].posandflag);
  479. }
  481. // Sort edge heap.  Note that we conveniently made the opening edges
  482. // one more than closing edges at the same spot, so we won't have any
  483. // problems with abutting spans.
  485. std::sort(heap.begin(), heap.end()/*begin() + heap.size()*/);
  487. // Process edges and add spans.  Since we only check for a non-zero
  488. // winding number, it doesn't matter which way the outlines go!
  490. std::vector<int>::iterator itX1 = heap.begin();
  491. std::vector<int>::iterator itX2 = heap.end(); // begin() + heap.size();
  493. int x1, x2;
  495. for(; itX1 != itX2; ++itX1)
  496. {
  497. int x = *itX1;
  499. if(!count) 
  500. x1 = (x>>1);
  502. if(x&1) 
  503. ++count;
  504. else 
  505. --count;
  507. if(!count)
  508. {
  509. x2 = (x>>1);
  511. if(x2>x1)
  512. mOutline.push_back(std::pair<__int64,__int64>((y<<32)+x1+0x4000000040000000i64, (y<<32)+x2+0x4000000040000000i64)); // G: damn Avery, this is evil! :)
  513. }
  514. }
  516. heap.clear();
  517. }
  519. // Dump the edge and scan buffers, since we no longer need them.
  521. free(mpEdgeBuffer);
  522. delete [] mpScanBuffer;
  524. // All done!
  526. return true;
  527. }
  529. using namespace std;
  531. void Rasterizer::_OverlapRegion(tSpanBuffer& dst, tSpanBuffer& src, int dx, int dy)
  532. {
  533. tSpanBuffer temp;
  535. temp.reserve(dst.size() + src.size());
  537. dst.swap(temp);
  539. tSpanBuffer::iterator itA = temp.begin();
  540. tSpanBuffer::iterator itAE = temp.end();
  541. tSpanBuffer::iterator itB = src.begin();
  542. tSpanBuffer::iterator itBE = src.end();
  544. // Don't worry -- even if dy<0 this will still work! // G: hehe, the evil twin :)
  546. unsigned __int64 offset1 = (((__int64)dy)<<32) - dx;
  547. unsigned __int64 offset2 = (((__int64)dy)<<32) + dx;
  549. while(itA != itAE && itB != itBE)
  550. {
  551. if((*itB).first + offset1 < (*itA).first)
  552. {
  553. // B span is earlier.  Use it.
  555. unsigned __int64 x1 = (*itB).first + offset1;
  556. unsigned __int64 x2 = (*itB).second + offset2;
  558. ++itB;
  560. // B spans don't overlap, so begin merge loop with A first.
  562. for(;;)
  563. {
  564. // If we run out of A spans or the A span doesn't overlap,
  565. // then the next B span can't either (because B spans don't
  566. // overlap) and we exit.
  568. if(itA == itAE || (*itA).first > x2)
  569. break;
  571. do {x2 = _MAX(x2, (*itA++).second);}
  572. while(itA != itAE && (*itA).first <= x2);
  574. // If we run out of B spans or the B span doesn't overlap,
  575. // then the next A span can't either (because A spans don't
  576. // overlap) and we exit.
  578. if(itB == itBE || (*itB).first + offset1 > x2)
  579. break;
  581. do {x2 = _MAX(x2, (*itB++).second + offset2);}
  582. while(itB != itBE && (*itB).first + offset1 <= x2);
  583. }
  585. // Flush span.
  587. dst.push_back(tSpan(x1, x2));
  588. }
  589. else
  590. {
  591. // A span is earlier.  Use it.
  593. unsigned __int64 x1 = (*itA).first;
  594. unsigned __int64 x2 = (*itA).second;
  596. ++itA;
  598. // A spans don't overlap, so begin merge loop with B first.
  600. for(;;)
  601. {
  602. // If we run out of B spans or the B span doesn't overlap,
  603. // then the next A span can't either (because A spans don't
  604. // overlap) and we exit.
  606. if(itB == itBE || (*itB).first + offset1 > x2)
  607. break;
  609. do {x2 = _MAX(x2, (*itB++).second + offset2);}
  610. while(itB != itBE && (*itB).first + offset1 <= x2);
  612. // If we run out of A spans or the A span doesn't overlap,
  613. // then the next B span can't either (because B spans don't
  614. // overlap) and we exit.
  616. if(itA == itAE || (*itA).first > x2)
  617. break;
  619. do {x2 = _MAX(x2, (*itA++).second);}
  620. while(itA != itAE && (*itA).first <= x2);
  621. }
  623. // Flush span.
  625. dst.push_back(tSpan(x1, x2));
  626. }
  627. }
  629. // Copy over leftover spans.
  631. while(itA != itAE)
  632. dst.push_back(*itA++);
  634. while(itB != itBE)
  635. {
  636. dst.push_back(tSpan((*itB).first + offset1, (*itB).second + offset2));
  637. ++itB;
  638. }
  639. }
  641. bool Rasterizer::CreateWidenedRegion(int r)
  642. {
  643. if(r < 0) r = 0;
  645. for(int y = -r; y <= r; ++y)
  646. {
  647. int x = (int)(0.5 + sqrt(float(r*r - y*y)));
  649. _OverlapRegion(mWideOutline, mOutline, x, y);
  650. }
  652. mWideBorder = r;
  654. return true;
  655. }
  657. void Rasterizer::DeleteOutlines()
  658. {
  659. mWideOutline.clear();
  660. mOutline.clear();
  661. }
  663. bool Rasterizer::Rasterize(int xsub, int ysub, bool fBlur)
  664. {
  665. _TrashOverlay();
  667. if(!mWidth || !mHeight)
  668. {
  669. mOverlayWidth = mOverlayHeight = 0;
  670. return true;
  671. }
  673. xsub &= 7;
  674. ysub &= 7;
  676. int width = mWidth + xsub;
  677. int height = mHeight + ysub;
  679. mOffsetX = mPathOffsetX - xsub;
  680. mOffsetY = mPathOffsetY - ysub;
  682. mWideBorder = (mWideBorder+7)&~7;
  684. if(!mWideOutline.empty())
  685. {
  686. width += 2*mWideBorder;
  687. height += 2*mWideBorder;
  689. xsub += mWideBorder;
  690. ysub += mWideBorder;
  692. mOffsetX -= mWideBorder;
  693. mOffsetY -= mWideBorder;
  694. }
  696. mOverlayWidth = ((width+7)>>3) + 1;
  697. mOverlayHeight = ((height+7)>>3) + 1;
  699. mpOverlayBuffer = new byte[2 * mOverlayWidth * mOverlayHeight];
  700. memset(mpOverlayBuffer, 0, 2 * mOverlayWidth * mOverlayHeight);
  702. // Are we doing a border?
  704. tSpanBuffer* pOutline[2] = {&mOutline, &mWideOutline};
  706. for(int i = countof(pOutline)-1; i >= 0; i--)
  707. {
  708. tSpanBuffer::iterator it = pOutline[i]->begin();
  709. tSpanBuffer::iterator itEnd = pOutline[i]->end();
  711. for(; it!=itEnd; ++it)
  712. {
  713. int y = (int)(((*it).first >> 32) - 0x40000000 + ysub);
  714. int x1 = (int)(((*it).first & 0xffffffff) - 0x40000000 + xsub);
  715. int x2 = (int)(((*it).second & 0xffffffff) - 0x40000000 + xsub);
  717. if(x2 > x1)
  718. {
  719. int first = x1>>3;
  720. int last = (x2-1)>>3;
  721. byte* dst = mpOverlayBuffer + 2*(mOverlayWidth*(y>>3) + first) + i;
  723. if(first == last)
  724. *dst += x2-x1;
  725. else
  726. {
  727. *dst += ((first+1)<<3) - x1;
  728. dst += 2;
  730. while(++first < last)
  731. {
  732. *dst += 0x08;
  733. dst += 2;
  734. }
  736. *dst += x2 - (last<<3);
  737. }
  738. }
  739. }
  740. }
  742. if(fBlur && mOverlayWidth >= 3 && mOverlayHeight >= 3)
  743. {
  744. int pitch = mOverlayWidth*2;
  746. byte* tmp = new byte[pitch*mOverlayHeight];
  747. if(!tmp) return(false);
  749. memcpy(tmp, mpOverlayBuffer, pitch*mOverlayHeight);
  751. int border = !mWideOutline.empty() ? 1 : 0;
  753. for(int j = 1; j < mOverlayHeight-1; j++)
  754. {
  755. byte* src = tmp + pitch*j + 2 + border;
  756. byte* dst = mpOverlayBuffer + pitch*j + 2 + border;
  758. for(int i = 1; i < mOverlayWidth-1; i++, src+=2, dst+=2)
  759. {
  760. *dst = (src[-2-pitch] + (src[-pitch]<<1) + src[+2-pitch]
  761. + (src[-2]<<1) + (src[0]<<2) + (src[+2]<<1)
  762. + src[-2+pitch] + (src[+pitch]<<1) + src[+2+pitch]) >> 4;
  763. }
  764. }
  766. delete [] tmp;
  767. }
  769. return true;
  770. }
  772. ///////////////////////////////////////////////////////////////////////////
  774. #define pixmix(s) {  
  775. int a = (((s)*(color>>24))>>6)&0xff;  
  776. int ia = 256-a;  
  777.  
  778. dst[wt] = ((((dst[wt]&0x00ff00ff)*ia + (color&0x00ff00ff)*a)&0xff00ff00)>>8) 
  779. | ((((dst[wt]&0x0000ff00)*ia + (color&0x0000ff00)*a)&0x00ff0000)>>8) 
  780. | ((((dst[wt]>>8)&0x00ff0000)*ia)&0xff000000);  
  781. } 
  783. #include <xmmintrin.h>
  784. #include <emmintrin.h>
  786. __forceinline void pixmix_sse2(DWORD* dst, DWORD color, DWORD alpha)
  787. {
  788. alpha = ((alpha * (color>>24)) >> 6) & 0xff;
  789. color &= 0xffffff;
  791. __m128i zero = _mm_setzero_si128();
  792. __m128i a = _mm_set1_epi32((alpha << 16) | (0x100 - alpha));
  793. __m128i d = _mm_unpacklo_epi8(_mm_cvtsi32_si128(*dst), zero);
  794. __m128i s = _mm_unpacklo_epi8(_mm_cvtsi32_si128(color), zero);
  795. __m128i r = _mm_unpacklo_epi16(d, s);
  797. r = _mm_madd_epi16(r, a);
  798. r = _mm_srli_epi32(r, 8);
  799. r = _mm_packs_epi32(r, r);
  800. r = _mm_packus_epi16(r, r);
  802. *dst = (DWORD)_mm_cvtsi128_si32(r);
  803. }
  805. #include "../dsutil/vd.h"
  807. CRect Rasterizer::Draw(SubPicDesc& spd, CRect& clipRect, byte* pAlphaMask, int xsub, int ysub, const long* switchpts, bool fBody, bool fBorder)
  808. {
  809. CRect bbox(0, 0, 0, 0);
  811. if(!switchpts || !fBody && !fBorder) return(bbox);
  813. // clip
  815. CRect r(0, 0, spd.w, spd.h);
  816. r &= clipRect;
  818. int x = (xsub + mOffsetX + 4)>>3;
  819. int y = (ysub + mOffsetY + 4)>>3;
  820. int w = mOverlayWidth;
  821. int h = mOverlayHeight;
  822. int xo = 0, yo = 0;
  824. if(x < r.left) {xo = r.left-x; w -= r.left-x; x = r.left;}
  825. if(y < r.top) {yo = r.top-y; h -= r.top-y; y = r.top;}
  826. if(x+w > r.right) w = r.right-x;
  827. if(y+h > r.bottom) h = r.bottom-y;
  829. if(w <= 0 || h <= 0) return(bbox);
  831. bbox.SetRect(x, y, x+w, y+h);
  832. bbox &= CRect(0, 0, spd.w, spd.h);
  834. // draw
  836. const byte* src = mpOverlayBuffer + 2*(mOverlayWidth * yo + xo);
  837. const byte* s = fBorder ? (src+1) : src;
  838. const byte* am = pAlphaMask + spd.w * y + x;
  839. unsigned long* dst = (unsigned long *)((char *)spd.bits + spd.pitch * y) + x;
  841. unsigned long color = switchpts[0];
  843. bool fSSE2 = !!(g_cpuid.m_flags & CCpuID::sse2);
  845. while(h--)
  846. {
  847. if(!pAlphaMask)
  848. {
  849. if(switchpts[1] == 0xffffffff)
  850. {
  851. if(fBody)
  852. {
  853. if(fSSE2) for(int wt=0; wt<w; ++wt) pixmix_sse2(&dst[wt], color, s[wt*2]);
  854. else for(int wt=0; wt<w; ++wt) pixmix(s[wt*2]);
  855. }
  856. else
  857. {
  858. if(fSSE2) for(int wt=0; wt<w; ++wt) pixmix_sse2(&dst[wt], color, src[wt*2+1] - src[wt*2]);
  859. else for(int wt=0; wt<w; ++wt) pixmix(src[wt*2+1] - src[wt*2]);
  860. }
  861. }
  862. else
  863. {
  864. const long *sw = switchpts;
  866. if(fBody)
  867. {
  868. if(fSSE2) 
  869. for(int wt=0; wt<w; ++wt)
  870. {
  871. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];}
  872. pixmix_sse2(&dst[wt], color, s[wt*2]);
  873. }
  874. else
  875. for(int wt=0; wt<w; ++wt)
  876. {
  877. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];}
  878. pixmix(s[wt*2]);
  879. }
  880. }
  881. else
  882. {
  883. if(fSSE2) 
  884. for(int wt=0; wt<w; ++wt)
  885. {
  886. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];} 
  887. pixmix_sse2(&dst[wt], color, src[wt*2+1] - src[wt*2]);
  888. }
  889. else
  890. for(int wt=0; wt<w; ++wt)
  891. {
  892. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];} 
  893. pixmix(src[wt*2+1] - src[wt*2]);
  894. }
  895. }
  896. }
  897. }
  898. else
  899. {
  900. if(switchpts[1] == 0xffffffff)
  901. {
  902. if(fBody)
  903. {
  904. if(fSSE2) for(int wt=0; wt<w; ++wt) pixmix_sse2(&dst[wt], color, s[wt*2] * am[wt]);
  905. else for(int wt=0; wt<w; ++wt) pixmix(s[wt*2] * am[wt]);
  906. }
  907. else
  908. {
  909. if(fSSE2) for(int wt=0; wt<w; ++wt) pixmix_sse2(&dst[wt], color, (src[wt*2+1] - src[wt*2]) * am[wt]);
  910. else for(int wt=0; wt<w; ++wt) pixmix((src[wt*2+1] - src[wt*2]) * am[wt]);
  911. }
  912. }
  913. else
  914. {
  915. const long *sw = switchpts;
  917. if(fBody)
  918. {
  919. if(fSSE2) 
  920. for(int wt=0; wt<w; ++wt)
  921. {
  922. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];}
  923. pixmix_sse2(&dst[wt], color, s[wt*2] * am[wt]);
  924. }
  925. else
  926. for(int wt=0; wt<w; ++wt)
  927. {
  928. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];}
  929. pixmix(s[wt*2] * am[wt]);
  930. }
  931. }
  932. else
  933. {
  934. if(fSSE2) 
  935. for(int wt=0; wt<w; ++wt)
  936. {
  937. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];} 
  938. pixmix_sse2(&dst[wt], color, (src[wt*2+1] - src[wt*2]) * am[wt]);
  939. }
  940. else
  941. for(int wt=0; wt<w; ++wt)
  942. {
  943. if(wt+xo >= sw[1]) {while(wt+xo >= sw[1]) sw += 2; color = sw[-2];} 
  944. pixmix((src[wt*2+1] - src[wt*2]) * am[wt]);
  945. }
  946. }
  947. }
  948. }
  950. src += 2*mOverlayWidth;
  951. s += 2*mOverlayWidth;
  952. am += spd.w;
  953. dst = (unsigned long *)((char *)dst + spd.pitch);
  954. }
  956. return bbox;
  957. }