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

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

多媒体编程

开发平台：

Visual C++

RTS.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 <math.h>
  24. #include <time.h>
  25. #include "RTS.h"
  27. // WARNING: this isn't very thread safe, use only one RTS a time.
  28. static HDC g_hDC;
  29. static int g_hDC_refcnt = 0;
  31. static long revcolor(long c)
  32. {
  33. return ((c&0xff0000)>>16) + (c&0xff00) + ((c&0xff)<<16);
  34. }
  36. //////////////////////////////////////////////////////////////////////////////////////////////
  38. // CMyFont
  40. CMyFont::CMyFont(STSStyle& style)
  41. {
  42. LOGFONT lf;
  43. memset(&lf, 0, sizeof(lf));
  44. lf <<= style;
  45. lf.lfHeight = (LONG)(style.fontSize+0.5);
  46. lf.lfOutPrecision = OUT_TT_PRECIS;
  47. lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  48. lf.lfQuality = ANTIALIASED_QUALITY;
  49. lf.lfPitchAndFamily = DEFAULT_PITCH|FF_DONTCARE;
  50. lf.lfEscapement = lf.lfOrientation = 0;
  51. if(!CreateFontIndirect(&lf))
  52. {
  53. _tcscpy(lf.lfFaceName, _T("Arial"));
  54. CreateFontIndirect(&lf);
  55. }
  57. HFONT hOldFont = (HFONT)SelectObject(g_hDC, *this);
  58. TEXTMETRIC tm;
  59. BOOL b = GetTextMetrics(g_hDC, &tm);
  60. DWORD ret = GetLastError();
  61. m_ascent = ((tm.tmAscent + 4) >> 3);
  62. m_descent = ((tm.tmDescent + 4) >> 3);
  63. SelectObject(g_hDC, hOldFont);
  64. }
  66. // CWord
  68. CWord::CWord(STSStyle& style, CStringW str, int ktype, int kstart, int kend) 
  69. : m_style(style), m_str(str)
  70. , m_width(0), m_ascent(0), m_descent(0)
  71. , m_ktype(ktype), m_kstart(kstart), m_kend(kend)
  72. , m_fDrawn(false), m_p(INT_MAX, INT_MAX)
  73. , m_fLineBreak(false), m_fWhiteSpaceChar(false)
  74. , m_pOpaqueBox(NULL)
  75. {
  76. if(str.IsEmpty()) 
  77. {
  78. m_fWhiteSpaceChar = m_fLineBreak = true; 
  79. }
  81. CMyFont font(m_style);
  82. m_ascent = (int)(m_style.fontScaleY/100*font.m_ascent);
  83. m_descent = (int)(m_style.fontScaleY/100*font.m_descent);
  84. m_width = 0;
  85. }
  87. CWord::~CWord()
  88. {
  89. if(m_pOpaqueBox) delete m_pOpaqueBox;
  90. }
  92. bool CWord::Append(CWord* w)
  93. {
  94. if(!(m_style == w->m_style)
  95. || m_fLineBreak || w->m_fLineBreak
  96. || w->m_kstart != w->m_kend || m_ktype != w->m_ktype) return(false);
  98. m_fWhiteSpaceChar = m_fWhiteSpaceChar && w->m_fWhiteSpaceChar;
  99. m_str += w->m_str;
  100. m_width += w->m_width;
  102. m_fDrawn = false;
  103. m_p = CPoint(INT_MAX, INT_MAX);
  105. return(true);
  106. }
  108. void CWord::Paint(CPoint p, CPoint org)
  109. {
  110. if(!m_str) return;
  112. if(!m_fDrawn)
  113. {
  114. if(!CreatePath()) return;
  116. Transform(CPoint((org.x-p.x)*8, (org.y-p.y)*8));
  118. if(!ScanConvert()) return;
  120. if(m_style.borderStyle == 0 && m_style.outlineWidth > 0)
  121. {
  122. if(!CreateWidenedRegion((int)(m_style.outlineWidth+0.5))) return;
  123. }
  124. else if(m_style.borderStyle == 1)
  125. {
  126. if(!CreateOpaqueBox()) return;
  127. }
  129. m_fDrawn = true;
  131. if(!Rasterize(p.x&7, p.y&7, m_style.fBlur)) return;
  132. }
  133. else if((m_p.x&7) != (p.x&7) || (m_p.y&7) != (p.y&7))
  134. {
  135. Rasterize(p.x&7, p.y&7, m_style.fBlur);
  136. }
  138. m_p = p;
  140. if(m_pOpaqueBox)
  141. m_pOpaqueBox->Paint(p, org);
  142. }
  144. void CWord::Transform(CPoint org)
  145. {
  146. double scalex = m_style.fontScaleX/100;
  147. double scaley = m_style.fontScaleY/100;
  149. double caz = cos((3.1415/180)*m_style.fontAngleZ);
  150. double saz = sin((3.1415/180)*m_style.fontAngleZ);
  151. double cax = cos((3.1415/180)*m_style.fontAngleX);
  152. double sax = sin((3.1415/180)*m_style.fontAngleX);
  153. double cay = cos((3.1415/180)*m_style.fontAngleY);
  154. double say = sin((3.1415/180)*m_style.fontAngleY);
  156. for(int i = 0; i < mPathPoints; i++)
  157. {
  158. double x, y, z, xx, yy, zz;
  160. x = scalex * mpPathPoints[i].x - org.x;
  161. y = scaley * mpPathPoints[i].y - org.y;
  162. z = 0;
  164. xx = x*caz + y*saz;
  165. yy = -(x*saz - y*caz);
  166. zz = z;
  168. x = xx;
  169. y = yy*cax + zz*sax;
  170. z = yy*sax - zz*cax;
  172. xx = x*cay + z*say;
  173. yy = y;
  174. zz = x*say - z*cay;
  176. zz = max(zz, -19000);
  178. x = (xx * 20000) / (zz + 20000);
  179. y = (yy * 20000) / (zz + 20000);
  181. mpPathPoints[i].x = (LONG)(x + org.x + 0.5);
  182. mpPathPoints[i].y = (LONG)(y + org.y + 0.5);
  183. }
  184. }
  186. bool CWord::CreateOpaqueBox()
  187. {
  188. if(m_pOpaqueBox) return(true);
  190. STSStyle style = m_style;
  191. style.borderStyle = 0;
  192. style.outlineWidth = 0;
  193. style.colors[0] = m_style.colors[2];
  194. style.alpha[0] = m_style.alpha[2];
  196. int w = (int)(m_style.outlineWidth + 0.5);
  198. CStringW str;
  199. str.Format(L"m %d %d l %d %d %d %d %d %d", 
  200. -w, -w, 
  201. m_width+w, -w, 
  202. m_width+w, m_ascent+m_descent+w, 
  203. -w, m_ascent+m_descent+w);
  205. m_pOpaqueBox = new CPolygon(style, str, 0, 0, 0, 1.0/8, 1.0/8, 0);
  207. return(!!m_pOpaqueBox);
  208. }
  210. // CText
  212. CText::CText(STSStyle& style, CStringW str, int ktype, int kstart, int kend)
  213. : CWord(style, str, ktype, kstart, kend)
  214. {
  215. if(m_str.GetLength() == 1 && m_str[0] == ' ')
  216. {
  217. m_fWhiteSpaceChar = true;
  218. }
  220. CMyFont font(m_style);
  222. HFONT hOldFont = (HFONT)SelectObject(g_hDC, font);
  224. if(m_style.fontSpacing || (long)GetVersion() < 0)
  225. {
  226. bool bFirstPath = true;
  228. for(LPCWSTR s = m_str; *s; s++)
  229. {
  230. CSize extent;
  231. if(!GetTextExtentPoint32W(g_hDC, s, 1, &extent)) {SelectObject(g_hDC, hOldFont); ASSERT(0); return;}
  232. m_width += extent.cx + (int)m_style.fontSpacing;
  233. }
  234. // m_width -= (int)m_style.fontSpacing; // TODO: subtract only at the end of the line
  235. }
  236. else
  237. {
  238. CSize extent;
  239. if(!GetTextExtentPoint32W(g_hDC, m_str, wcslen(str), &extent)) {SelectObject(g_hDC, hOldFont); ASSERT(0); return;}
  240. m_width += extent.cx;
  241. }
  243. m_width = (int)(m_style.fontScaleX/100*m_width + 4) >> 3;
  245. SelectObject(g_hDC, hOldFont);
  246. }
  248. CWord* CText::Copy()
  249. {
  250. return(new CText(m_style, m_str, m_ktype, m_kstart, m_kend));
  251. }
  253. bool CText::Append(CWord* w)
  254. {
  255. return(dynamic_cast<CText*>(w) && CWord::Append(w));
  256. }
  258. bool CText::CreatePath()
  259. {
  260. CMyFont font(m_style);
  261. HFONT hOldFont = (HFONT)SelectObject(g_hDC, font);
  263. int width = 0;
  265. if(m_style.fontSpacing || (long)GetVersion() < 0)
  266. {
  267. bool bFirstPath = true;
  269. for(LPCWSTR s = m_str; *s; s++)
  270. {
  271. CSize extent;
  272. if(!GetTextExtentPoint32W(g_hDC, s, 1, &extent)) {SelectObject(g_hDC, hOldFont); ASSERT(0); return(false);}
  274. PartialBeginPath(g_hDC, bFirstPath); bFirstPath = false;
  275. TextOutW(g_hDC, 0, 0, s, 1);
  276. PartialEndPath(g_hDC, width, 0);
  278. width += extent.cx + (int)m_style.fontSpacing;
  279. }
  280. }
  281. else
  282. {
  283. CSize extent;
  284. if(!GetTextExtentPoint32W(g_hDC, m_str, m_str.GetLength(), &extent)) {SelectObject(g_hDC, hOldFont); ASSERT(0); return(false);}
  286. BeginPath(g_hDC);
  287. TextOutW(g_hDC, 0, 0, m_str, m_str.GetLength());
  288. EndPath(g_hDC);
  289. }
  291. SelectObject(g_hDC, hOldFont);
  293. return(true);
  294. }
  296. // CPolygon
  298. CPolygon::CPolygon(STSStyle& style, CStringW str, int ktype, int kstart, int kend, double scalex, double scaley, int baseline) 
  299. : CWord(style, str, ktype, kstart, kend)
  300. , m_scalex(scalex), m_scaley(scaley), m_baseline(baseline)
  301. {
  302. ParseStr();
  303. }
  305. CPolygon::~CPolygon()
  306. {
  307. }
  309. CWord* CPolygon::Copy()
  310. {
  311. return(new CPolygon(m_style, m_str, m_ktype, m_kstart, m_kend, m_scalex, m_scaley, m_baseline));
  312. }
  314. bool CPolygon::Append(CWord* w)
  315. {
  316. int width = m_width;
  318. CPolygon* p = dynamic_cast<CPolygon*>(w);
  319. if(!p) return(false);
  321. // TODO
  322. return(false);
  324. return(true);
  325. }
  327. bool CPolygon::GetLONG(CStringW& str, LONG& ret)
  328. {
  329. LPWSTR s = (LPWSTR)(LPCWSTR)str, e = s;
  330. ret = wcstol(str, &e, 10);
  331. str = str.Mid(e - s);
  332. return(e > s);
  333. }
  335. bool CPolygon::GetPOINT(CStringW& str, POINT& ret)
  336. {
  337. return(GetLONG(str, ret.x) && GetLONG(str, ret.y));
  338. }
  340. bool CPolygon::ParseStr()
  341. {
  342. if(m_pathTypesOrg.GetSize() > 0) return(true);
  344. CPoint p;
  345. int i, j, lastsplinestart = -1, firstmoveto = -1, lastmoveto = -1;
  347. CStringW str = m_str;
  348. str.SpanIncluding(L"mnlbspc 0123456789");
  349. str.Replace(L"m", L"*m");
  350. str.Replace(L"n", L"*n");
  351. str.Replace(L"l", L"*l");
  352. str.Replace(L"b", L"*b");
  353. str.Replace(L"s", L"*s");
  354. str.Replace(L"p", L"*p");
  355. str.Replace(L"c", L"*c");
  357. int k = 0;
  358. for(CStringW s = str.Tokenize(L"*", k); !s.IsEmpty(); s = str.Tokenize(L"*", k))
  359. {
  360. WCHAR c = s[0];
  361. s.TrimLeft(L"mnlbspc ");
  362. switch(c)
  363. {
  364. case 'm': 
  365. lastmoveto = m_pathTypesOrg.GetSize();
  366. if(firstmoveto == -1) firstmoveto = lastmoveto;
  367. while(GetPOINT(s, p)) {m_pathTypesOrg.Add(PT_MOVETO); m_pathPointsOrg.Add(p);}
  368. break;
  369. case 'n':
  370. while(GetPOINT(s, p)) {m_pathTypesOrg.Add(PT_MOVETONC); m_pathPointsOrg.Add(p);}
  371. break;
  372. case 'l':
  373. while(GetPOINT(s, p)) {m_pathTypesOrg.Add(PT_LINETO); m_pathPointsOrg.Add(p);}
  374. break;
  375. case 'b':
  376. j = m_pathTypesOrg.GetSize();
  377. while(GetPOINT(s, p)) {m_pathTypesOrg.Add(PT_BEZIERTO); m_pathPointsOrg.Add(p); j++;}
  378. j = m_pathTypesOrg.GetSize() - ((m_pathTypesOrg.GetSize()-j)%3);
  379. m_pathTypesOrg.SetSize(j); m_pathPointsOrg.SetSize(j);
  380. break;
  381. case 's':
  382. j = lastsplinestart = m_pathTypesOrg.GetSize();
  383. i = 3;
  384. while(i-- && GetPOINT(s, p)) {m_pathTypesOrg.Add(PT_BSPLINETO); m_pathPointsOrg.Add(p); j++;}
  385. if(m_pathTypesOrg.GetSize()-lastsplinestart < 3) {m_pathTypesOrg.SetSize(lastsplinestart); m_pathPointsOrg.SetSize(lastsplinestart); lastsplinestart = -1;}
  386. // no break here
  387. case 'p':
  388. while(GetPOINT(s, p)) {m_pathTypesOrg.Add(PT_BSPLINEPATCHTO); m_pathPointsOrg.Add(p); j++;}
  389. break;
  390. case 'c':
  391. if(lastsplinestart > 0)
  392. {
  393. m_pathTypesOrg.Add(PT_BSPLINEPATCHTO);
  394. m_pathTypesOrg.Add(PT_BSPLINEPATCHTO);
  395. m_pathTypesOrg.Add(PT_BSPLINEPATCHTO);
  396. p = m_pathPointsOrg[lastsplinestart-1]; // we need p for temp storage, because operator [] will return a reference to CPoint and Add() may reallocate its internal buffer (this is true for MFC 7.0 but not for 6.0, hehe)
  397. m_pathPointsOrg.Add(p);
  398. p = m_pathPointsOrg[lastsplinestart];
  399. m_pathPointsOrg.Add(p);
  400. p = m_pathPointsOrg[lastsplinestart+1];
  401. m_pathPointsOrg.Add(p);
  402. lastsplinestart = -1;
  403. }
  404. break;
  405. default:
  406. break;
  407. }
  408. }
  409. /*
  410. LPCWSTR str = m_str;
  411. while(*str)
  412. {
  413. while(*str && *str != 'm' && *str != 'n' && *str != 'l' && *str != 'b' && *str != 's' && *str != 'p' && *str != 'c') str++;
  415. if(!*str) break;
  417. switch(*str++)
  418. {
  419. case 'm': 
  420. lastmoveto = m_pathTypesOrg.GetSize();
  421. if(firstmoveto == -1) firstmoveto = lastmoveto;
  422. while(GetPOINT(str, p)) {m_pathTypesOrg.Add(PT_MOVETO); m_pathPointsOrg.Add(p);}
  423. break;
  424. case 'n':
  425. while(GetPOINT(str, p)) {m_pathTypesOrg.Add(PT_MOVETONC); m_pathPointsOrg.Add(p);}
  426. break;
  427. case 'l':
  428. while(GetPOINT(str, p)) {m_pathTypesOrg.Add(PT_LINETO); m_pathPointsOrg.Add(p);}
  429. break;
  430. case 'b':
  431. j = m_pathTypesOrg.GetSize();
  432. while(GetPOINT(str, p)) {m_pathTypesOrg.Add(PT_BEZIERTO); m_pathPointsOrg.Add(p); j++;}
  433. j = m_pathTypesOrg.GetSize() - ((m_pathTypesOrg.GetSize()-j)%3);
  434. m_pathTypesOrg.SetSize(j); m_pathPointsOrg.SetSize(j);
  435. break;
  436. case 's':
  437. j = lastsplinestart = m_pathTypesOrg.GetSize();
  438. i = 3;
  439. while(i-- && GetPOINT(str, p)) {m_pathTypesOrg.Add(PT_BSPLINETO); m_pathPointsOrg.Add(p); j++;}
  440. if(m_pathTypesOrg.GetSize()-lastsplinestart < 3) {m_pathTypesOrg.SetSize(lastsplinestart); m_pathPointsOrg.SetSize(lastsplinestart); lastsplinestart = -1;}
  441. // no break here
  442. case 'p':
  443. while(GetPOINT(str, p)) {m_pathTypesOrg.Add(PT_BSPLINEPATCHTO); m_pathPointsOrg.Add(p); j++;}
  444. break;
  445. case 'c':
  446. if(lastsplinestart > 0)
  447. {
  448. m_pathTypesOrg.Add(PT_BSPLINEPATCHTO);
  449. m_pathTypesOrg.Add(PT_BSPLINEPATCHTO);
  450. m_pathTypesOrg.Add(PT_BSPLINEPATCHTO);
  451. p = m_pathPointsOrg[lastsplinestart-1]; // we need p for temp storage, because operator [] will return a reference to CPoint and Add() may reallocate its internal buffer (this is true for MFC 7.0 but not for 6.0, hehe)
  452. m_pathPointsOrg.Add(p);
  453. p = m_pathPointsOrg[lastsplinestart];
  454. m_pathPointsOrg.Add(p);
  455. p = m_pathPointsOrg[lastsplinestart+1];
  456. m_pathPointsOrg.Add(p);
  457. lastsplinestart = -1;
  458. }
  459. break;
  460. default:
  461. break;
  462. }
  464. if(firstmoveto > 0) break;
  465. }
  466. */
  467. if(lastmoveto == -1 || firstmoveto > 0) 
  468. {
  469. m_pathTypesOrg.RemoveAll();
  470. m_pathPointsOrg.RemoveAll();
  471. return(false);
  472. }
  474. int minx = INT_MAX, miny = INT_MAX, maxx = -INT_MAX, maxy = -INT_MAX;
  476. for(i = 0; i < m_pathTypesOrg.GetSize(); i++)
  477. {
  478. m_pathPointsOrg[i].x = (int)(64 * m_scalex * m_pathPointsOrg[i].x);
  479. m_pathPointsOrg[i].y = (int)(64 * m_scaley * m_pathPointsOrg[i].y);
  480. if(minx > m_pathPointsOrg[i].x) minx = m_pathPointsOrg[i].x;
  481. if(miny > m_pathPointsOrg[i].y) miny = m_pathPointsOrg[i].y;
  482. if(maxx < m_pathPointsOrg[i].x) maxx = m_pathPointsOrg[i].x;
  483. if(maxy < m_pathPointsOrg[i].y) maxy = m_pathPointsOrg[i].y;
  484. }
  486. m_width = max(maxx - minx, 0);
  487. m_ascent = max(maxy - miny, 0);
  489. int baseline = (int)(64 * m_scaley * m_baseline);
  490. m_descent = baseline;
  491. m_ascent -= baseline;
  493. m_width = ((int)(m_style.fontScaleX/100 * m_width) + 4) >> 3;
  494. m_ascent = ((int)(m_style.fontScaleY/100 * m_ascent) + 4) >> 3;
  495. m_descent = ((int)(m_style.fontScaleY/100 * m_descent) + 4) >> 3;
  497. return(true);
  498. }
  500. bool CPolygon::CreatePath()
  501. {
  502. int len = m_pathTypesOrg.GetSize();
  503. if(len == 0) return(false);
  505. if(mPathPoints != len)
  506. {
  507. mpPathTypes = (BYTE*)realloc(mpPathTypes, len*sizeof(BYTE));
  508. mpPathPoints = (POINT*)realloc(mpPathPoints, len*sizeof(POINT));
  509. if(!mpPathTypes || !mpPathPoints) return(false);
  510. mPathPoints = len;
  511. }
  513. memcpy(mpPathTypes, m_pathTypesOrg.GetData(), len*sizeof(BYTE));
  514. memcpy(mpPathPoints, m_pathPointsOrg.GetData(), len*sizeof(POINT));
  516. return(true);
  517. }
  519. // CClipper
  521. CClipper::CClipper(CStringW str, CSize size, double scalex, double scaley) 
  522. : CPolygon(STSStyle(), str, 0, 0, 0, scalex, scaley, 0)
  523. {
  524. m_size.cx = m_size.cy = 0;
  525. m_pAlphaMask = NULL;
  527. if(size.cx < 0 || size.cy < 0 || !(m_pAlphaMask = new BYTE[size.cx*size.cy])) return;
  529. m_size = size;
  531. memset(m_pAlphaMask, 0, size.cx*size.cy);
  533. Paint(CPoint(0, 0), CPoint(0, 0));
  535. int w = mOverlayWidth, h = mOverlayHeight;
  537. int x = (mOffsetX+4)>>3, y = (mOffsetY+4)>>3;
  538. int xo = 0, yo = 0;
  540. if(x < 0) {xo = -x; w -= -x; x = 0;}
  541. if(y < 0) {yo = -y; h -= -y; y = 0;}
  542. if(x+w > m_size.cx) w = m_size.cx-x;
  543. if(y+h > m_size.cy) h = m_size.cy-y;
  545. if(w <= 0 || h <= 0) return;
  547. const BYTE* src = mpOverlayBuffer + 2*(mOverlayWidth * yo + xo);
  548. BYTE* dst = m_pAlphaMask + m_size.cx * y + x;
  550. while(h--)
  551. {
  552. for(int wt=0; wt<w; ++wt)
  553. dst[wt] = src[wt*2];
  555. src += 2*mOverlayWidth;
  556. dst += m_size.cx;
  557. }
  558. }
  560. CClipper::~CClipper()
  561. {
  562. if(m_pAlphaMask) delete [] m_pAlphaMask;
  563. m_pAlphaMask = NULL;
  564. }
  566. CWord* CClipper::Copy()
  567. {
  568. return(new CClipper(m_str, m_size, m_scalex, m_scaley));
  569. }
  571. bool CClipper::Append(CWord* w)
  572. {
  573. return(false);
  574. }
  576. // CLine
  578. CLine::~CLine()
  579. {
  580. POSITION pos = GetHeadPosition();
  581. while(pos) delete GetNext(pos);
  582. }
  584. void CLine::Compact()
  585. {
  586. POSITION pos = GetHeadPosition();
  587. while(pos)
  588. {
  589. CWord* w = GetNext(pos);
  590. if(!w->m_fWhiteSpaceChar) break;
  592. m_width -= w->m_width;
  593. delete w;
  594. RemoveHead();
  595. }
  597. pos = GetTailPosition();
  598. while(pos)
  599. {
  600. CWord* w = GetPrev(pos);
  601. if(!w->m_fWhiteSpaceChar) break;
  603. m_width -= w->m_width;
  604. delete w;
  605. RemoveTail();
  606. }
  608. if(IsEmpty()) return;
  610. CLine l;
  611. l.AddTail(this);
  612. RemoveAll();
  614. CWord* last = NULL;
  616. pos = l.GetHeadPosition();
  617. while(pos)
  618. {
  619. CWord* w = l.GetNext(pos);
  621. if(!last || !last->Append(w))
  622. AddTail(last = w->Copy());
  623. }
  625. m_ascent = m_descent = m_border = 0;
  627. pos = GetHeadPosition();
  628. while(pos)
  629. {
  630. CWord* w = GetNext(pos);
  632. if(m_ascent < w->m_ascent) m_ascent = w->m_ascent;
  633. if(m_descent < w->m_descent) m_descent = w->m_descent;
  634. if(m_border < w->m_style.outlineWidth) m_border = (int)(w->m_style.outlineWidth+0.5);
  635. }
  636. }
  638. CRect CLine::PaintShadow(SubPicDesc& spd, CRect& clipRect, BYTE* pAlphaMask, CPoint p, CPoint org, int time, int alpha)
  639. {
  640. CRect bbox(0, 0, 0, 0);
  642. POSITION pos = GetHeadPosition();
  643. while(pos)
  644. {
  645. CWord* w = GetNext(pos);
  647. if(w->m_fLineBreak) return(bbox); // should not happen since this class is just a line of text without any breaks
  649. if(w->m_style.shadowDepth > 0)
  650. {
  651. int x = p.x + (int)(w->m_style.shadowDepth+0.5);
  652. int y = p.y + m_ascent - w->m_ascent + (int)(w->m_style.shadowDepth+0.5);
  654. DWORD a = 0xff - w->m_style.alpha[3];
  655. if(alpha > 0) a = MulDiv(a, 0xff - alpha, 0xff);
  656. COLORREF shadow = revcolor(w->m_style.colors[3]) | (a<<24);
  657. long sw[6] = {shadow, -1};
  659. w->Paint(CPoint(x, y), org);
  661. if(w->m_style.borderStyle == 0)
  662. {
  663. bbox |= w->Draw(spd, clipRect, pAlphaMask, x, y, sw, 
  664. w->m_ktype > 0 || w->m_style.alpha[0] < 0xff, 
  665. w->m_style.outlineWidth > 0 && !(w->m_ktype == 2 && time < w->m_kstart));
  666. }
  667. else if(w->m_style.borderStyle == 1 && w->m_pOpaqueBox)
  668. {
  669. bbox |= w->m_pOpaqueBox->Draw(spd, clipRect, pAlphaMask, x, y, sw, true, false);
  670. }
  671. }
  673. p.x += w->m_width;
  674. }
  676. return(bbox);
  677. }
  679. CRect CLine::PaintOutline(SubPicDesc& spd, CRect& clipRect, BYTE* pAlphaMask, CPoint p, CPoint org, int time, int alpha)
  680. {
  681. CRect bbox(0, 0, 0, 0);
  683. POSITION pos = GetHeadPosition();
  684. while(pos)
  685. {
  686. CWord* w = GetNext(pos);
  688. if(w->m_fLineBreak) return(bbox); // should not happen since this class is just a line of text without any breaks
  690. // if((w->m_style.outlineWidth > 0 || w->m_style.borderStyle == 1 && w->m_style.outlineWidth == 0) && !(w->m_ktype == 2 && time < w->m_kstart))
  691. if(w->m_style.outlineWidth > 0 && !(w->m_ktype == 2 && time < w->m_kstart))
  692. {
  693. int x = p.x;
  694. int y = p.y + m_ascent - w->m_ascent;
  696. DWORD aoutline = w->m_style.alpha[2];
  697. if(alpha > 0) aoutline += MulDiv(alpha, 0xff - w->m_style.alpha[2], 0xff);
  698. COLORREF outline = revcolor(w->m_style.colors[2]) | ((0xff-aoutline)<<24);
  699. long sw[6] = {outline, -1};
  701. w->Paint(CPoint(x, y), org);
  703. if(w->m_style.borderStyle == 0)
  704. {
  705. bbox |= w->Draw(spd, clipRect, pAlphaMask, x, y, sw, !w->m_style.alpha[0] && !w->m_style.alpha[1], true);
  706. }
  707. else if(w->m_style.borderStyle == 1 && w->m_pOpaqueBox)
  708. {
  709. bbox |= w->m_pOpaqueBox->Draw(spd, clipRect, pAlphaMask, x, y, sw, true/*!w->m_style.alpha[0] && !w->m_style.alpha[1]*/, false);
  710. }
  711. }
  713. p.x += w->m_width;
  714. }
  716. return(bbox);
  717. }
  719. CRect CLine::PaintBody(SubPicDesc& spd, CRect& clipRect, BYTE* pAlphaMask, CPoint p, CPoint org, int time, int alpha)
  720. {
  721. CRect bbox(0, 0, 0, 0);
  723. POSITION pos = GetHeadPosition();
  724. while(pos)
  725. {
  726. CWord* w = GetNext(pos);
  728. if(w->m_fLineBreak) return(bbox); // should not happen since this class is just a line of text without any breaks
  730. int x = p.x;
  731. int y = p.y + m_ascent - w->m_ascent;
  733. // colors
  735. DWORD aprimary = w->m_style.alpha[0];
  736. if(alpha > 0) aprimary += MulDiv(alpha, 0xff - w->m_style.alpha[0], 0xff);
  737. COLORREF primary = revcolor(w->m_style.colors[0]) | ((0xff-aprimary)<<24);
  739. DWORD asecondary = w->m_style.alpha[1];
  740. if(alpha > 0) asecondary += MulDiv(alpha, 0xff - w->m_style.alpha[1], 0xff);
  741. COLORREF secondary = revcolor(w->m_style.colors[1]) | ((0xff-asecondary)<<24);
  743. long sw[6] = {primary, 0, secondary};
  745. // karaoke
  747. double t;
  749. if(w->m_ktype == 0 || w->m_ktype == 2)
  750. {
  751. t = time < w->m_kstart ? 0 : 1;
  752. }
  753. else if(w->m_ktype == 1)
  754. {
  755. if(time < w->m_kstart) t = 0;
  756. else if(time < w->m_kend) 
  757. {
  758. t = 1.0 * (time - w->m_kstart) / (w->m_kend - w->m_kstart);
  760. double angle = fmod(w->m_style.fontAngleZ, 360.0);
  761. if(angle > 90 && angle < 270) 
  762. {
  763. t = 1-t;
  764. COLORREF tmp = sw[0]; sw[0] = sw[2]; sw[2] = tmp;
  765. }
  766. }
  767. else t = 1.0;
  768. }
  770. if(t >= 1)
  771. {
  772. sw[1] = 0xffffffff;
  773. }
  775. sw[3] = (int)(w->m_style.outlineWidth + t*w->m_width) >> 3;
  776. sw[4] = sw[2];
  777. sw[5] = 0x00ffffff;
  779. w->Paint(CPoint(x, y), org);
  781. bbox |= w->Draw(spd, clipRect, pAlphaMask, x, y, sw, true, false);
  783. p.x += w->m_width;
  784. }
  786. return(bbox);
  787. }
  790. // CSubtitle
  792. CSubtitle::CSubtitle()
  793. {
  794. memset(m_effects, 0, sizeof(Effect*)*EF_NUMBEROFEFFECTS);
  795. m_pClipper = NULL;
  796. m_scalex = m_scaley = 1;
  797. }
  799. CSubtitle::~CSubtitle()
  800. {
  801. Empty();
  802. }
  804. void CSubtitle::Empty()
  805. {
  806. POSITION pos = GetHeadPosition();
  807. while(pos) delete GetNext(pos);
  809. pos = m_words.GetHeadPosition();
  810. while(pos) delete m_words.GetNext(pos);
  812. for(int i = 0; i < EF_NUMBEROFEFFECTS; i++) {if(m_effects[i]) delete m_effects[i];}
  813. memset(m_effects, 0, sizeof(Effect*)*EF_NUMBEROFEFFECTS);
  815. if(m_pClipper) delete m_pClipper;
  816. m_pClipper = NULL;
  817. }
  819. int CSubtitle::GetFullWidth()
  820. {
  821. int width = 0;
  823. POSITION pos = m_words.GetHeadPosition();
  824. while(pos) width += m_words.GetNext(pos)->m_width;
  826. return(width);
  827. }
  829. int CSubtitle::GetFullLineWidth(POSITION pos)
  830. {
  831. int width = 0;
  833. while(pos) 
  834. {
  835. CWord* w = m_words.GetNext(pos);
  836. if(w->m_fLineBreak) break;
  837. width += w->m_width;
  838. }
  840. return(width);
  841. }
  843. int CSubtitle::GetWrapWidth(POSITION pos, int maxwidth)
  844. {
  845. if(m_wrapStyle == 0 || m_wrapStyle == 3)
  846. {
  847. if(maxwidth > 0) 
  848. {
  849. // int fullwidth = GetFullWidth();
  850. int fullwidth = GetFullLineWidth(pos);
  852. int minwidth = fullwidth / ((abs(fullwidth) / maxwidth) + 1);
  854. int width = 0, wordwidth = 0;
  856. while(pos && width < minwidth)
  857. {
  858. CWord* w = m_words.GetNext(pos);
  859. wordwidth = w->m_width;
  860. if(abs(width + wordwidth) < abs(maxwidth)) width += wordwidth;
  861. }
  863. maxwidth = width;
  865. if(m_wrapStyle == 3 && pos) maxwidth -= wordwidth;
  866. }
  867. }
  868. else if(m_wrapStyle == 1)
  869. {
  870. // maxwidth = maxwidth;
  871. }
  872. else if(m_wrapStyle == 2)
  873. {
  874. maxwidth = INT_MAX;
  875. }
  877. return(maxwidth);
  878. }
  880. CLine* CSubtitle::GetNextLine(POSITION& pos, int maxwidth)
  881. {
  882. if(pos == NULL) return(NULL);
  884. CLine* ret = new CLine();
  885. if(!ret) return(NULL);
  887. ret->m_width = ret->m_ascent = ret->m_descent = ret->m_border = 0;
  889. maxwidth = GetWrapWidth(pos, maxwidth);
  891. bool fEmptyLine = true;
  893. while(pos)
  894. {
  895. CWord* w = m_words.GetNext(pos);
  897. if(ret->m_ascent < w->m_ascent) ret->m_ascent = w->m_ascent;
  898. if(ret->m_descent < w->m_descent) ret->m_descent = w->m_descent;
  899. if(ret->m_border < w->m_style.outlineWidth) ret->m_border = (int)(w->m_style.outlineWidth+0.5);
  901. if(w->m_fLineBreak) 
  902. {
  903. if(fEmptyLine) {ret->m_ascent /= 2; ret->m_descent /= 2; ret->m_border = 0;}
  905. ret->Compact();
  907. return(ret);
  908. }
  910. fEmptyLine = false;
  912. bool fWSC = w->m_fWhiteSpaceChar;
  914. int width = w->m_width;
  915. POSITION pos2 = pos;
  916. while(pos2)
  917. {
  918. if(m_words.GetAt(pos2)->m_fWhiteSpaceChar != fWSC
  919. || m_words.GetAt(pos2)->m_fLineBreak) break;
  921. CWord* w2 = m_words.GetNext(pos2);
  922. width += w2->m_width;
  923. }
  925. if((ret->m_width += width) <= maxwidth || ret->IsEmpty()) 
  926. {
  927. ret->AddTail(w->Copy());
  929. while(pos != pos2)
  930. {
  931. ret->AddTail(m_words.GetNext(pos)->Copy());
  932. }
  934. pos = pos2;
  935. }
  936. else
  937. {
  938. if(pos) m_words.GetPrev(pos);
  939. else pos = m_words.GetTailPosition();
  941. ret->m_width -= width;
  943. break;
  944. }
  945. }
  947. ret->Compact();
  949. return(ret);
  950. }
  952. void CSubtitle::CreateClippers(CSize size)
  953. {
  954. size.cx >>= 3;
  955. size.cy >>= 3;
  957. if(m_effects[EF_BANNER] && m_effects[EF_BANNER]->param[2])
  958. {
  959. int width = m_effects[EF_BANNER]->param[2];
  961. int w = size.cx, h = size.cy;
  963. if(!m_pClipper) 
  964. {
  965. CStringW str;
  966. str.Format(L"m %d %d l %d %d %d %d %d %d", 0, 0, w, 0, w, h, 0, h);
  967. m_pClipper = new CClipper(str, size, 1, 1);
  968. if(!m_pClipper) return;
  969. }
  971. int da = (64<<8)/width;
  972. BYTE* am = m_pClipper->m_pAlphaMask;
  974. for(int j = 0; j < h; j++, am += w)
  975. {
  976. int a = 0;
  977. int k = min(width, w);
  979. for(int i = 0; i < k; i++, a += da)
  980. am[i] = (am[i]*a)>>14;
  982. a = 0x40<<8;
  983. k = w-width;
  985. if(k < 0) {a -= -k*da; k = 0;}
  986.             
  987. for(int i = k; i < w; i++, a -= da)
  988. am[i] = (am[i]*a)>>14;
  989. }
  990. }
  991. else if(m_effects[EF_SCROLL] && m_effects[EF_SCROLL]->param[4])
  992. {
  993. int height = m_effects[EF_SCROLL]->param[4];
  995. int w = size.cx, h = size.cy;
  997. if(!m_pClipper) 
  998. {
  999. CStringW str;
  1000. str.Format(L"m %d %d l %d %d %d %d %d %d", 0, 0, w, 0, w, h, 0, h);
  1001. m_pClipper = new CClipper(str, size, 1, 1);
  1002. if(!m_pClipper) return;
  1003. }
  1005. int da = (64<<8)/height;
  1006. int a = 0;
  1007. int k = m_effects[EF_SCROLL]->param[0]>>3;
  1008. int l = k+height;
  1009. if(k < 0) {a += -k*da; k = 0;}
  1010. if(l > h) {l = h;}
  1012. if(k < h)
  1013. {
  1014. BYTE* am = &m_pClipper->m_pAlphaMask[k*w];
  1016. memset(m_pClipper->m_pAlphaMask, 0, am - m_pClipper->m_pAlphaMask);
  1018. for(int j = k; j < l; j++, a += da)
  1019. {
  1020. for(int i = 0; i < w; i++, am++)
  1021. *am = ((*am)*a)>>14;
  1022. }
  1023. }
  1025. da = -(64<<8)/height;
  1026. a = 0x40<<8;
  1027. l = m_effects[EF_SCROLL]->param[1]>>3;
  1028. k = l-height;
  1029. if(k < 0) {a += -k*da; k = 0;}
  1030. if(l > h) {l = h;}
  1032. if(k < h)
  1033. {
  1034. BYTE* am = &m_pClipper->m_pAlphaMask[k*w];
  1036. int j = k;
  1037. for(; j < l; j++, a += da)
  1038. {
  1039. for(int i = 0; i < w; i++, am++)
  1040. *am = ((*am)*a)>>14;
  1041. }
  1043. memset(am, 0, (h-j)*w);
  1044. }
  1045. }
  1046. }
  1048. void CSubtitle::MakeLines(CSize size, CRect marginRect)
  1049. {
  1050. CSize spaceNeeded(0, 0);
  1052. bool fFirstLine = true;
  1054. m_topborder = m_bottomborder = 0;
  1056. CLine* l = NULL;
  1058. POSITION pos = m_words.GetHeadPosition();
  1059. while(pos)
  1060. {
  1061. l = GetNextLine(pos, size.cx - marginRect.left - marginRect.right);
  1062. if(!l) break;
  1064. if(fFirstLine) {m_topborder = l->m_border; fFirstLine = false;}
  1066. spaceNeeded.cx = max(l->m_width, spaceNeeded.cx);
  1067. spaceNeeded.cy += l->m_ascent + l->m_descent;
  1069. AddTail(l);
  1070. }
  1072. if(l) m_bottomborder = l->m_border;
  1074. m_rect = CRect(
  1075. CPoint((m_scrAlignment%3) == 1 ? marginRect.left
  1076. : (m_scrAlignment%3) == 2 ? (marginRect.left + (size.cx - marginRect.right) - spaceNeeded.cx + 1) / 2
  1077. : (size.cx - marginRect.right - spaceNeeded.cx),
  1078. m_scrAlignment <= 3 ? (size.cy - marginRect.bottom - spaceNeeded.cy)
  1079. : m_scrAlignment <= 6 ? (marginRect.top + (size.cy - marginRect.bottom) - spaceNeeded.cy + 1) / 2
  1080. : marginRect.top),
  1081. spaceNeeded);
  1082. }
  1084. // CScreenLayoutAllocator
  1086. void CScreenLayoutAllocator::Empty()
  1087. {
  1088. m_subrects.RemoveAll();
  1089. }
  1091. void CScreenLayoutAllocator::AdvanceToSegment(int segment, const CSubArray& sa)
  1092. {
  1093. POSITION pos = m_subrects.GetHeadPosition();
  1094. while(pos)
  1095. {
  1096. POSITION prev = pos;
  1098. SubRect& sr = m_subrects.GetNext(pos);
  1100. bool fFound = false;
  1102. if(abs(sr.segment - segment) <= 1) // using abs() makes it possible to play the subs backwards, too :)
  1103. {
  1104. for(int i = 0; i < sa.GetSize() && !fFound; i++)
  1105. {
  1106. if(sa[i] == sr.entry) 
  1107. {
  1108. sr.segment = segment;
  1109. fFound = true;
  1110. }
  1111. }
  1112. }
  1114. if(!fFound) m_subrects.RemoveAt(prev);
  1115. }
  1116. }
  1118. CRect CScreenLayoutAllocator::AllocRect(CSubtitle* s, int segment, int entry, int layer, int collisions)
  1119. {
  1120. // TODO: handle collisions == 1 (reversed collisions)
  1122. POSITION pos = m_subrects.GetHeadPosition();
  1123. while(pos)
  1124. {
  1125. SubRect& sr = m_subrects.GetNext(pos);
  1126. if(sr.segment == segment && sr.entry == entry) 
  1127. {
  1128. return(sr.r + CRect(0, -s->m_topborder, 0, -s->m_bottomborder));
  1129. }
  1130. }
  1132. CRect r = s->m_rect + CRect(0, s->m_topborder, 0, s->m_bottomborder);
  1134. bool fSearchDown = s->m_scrAlignment > 3;
  1136. bool fOK;
  1138. do
  1139. {
  1140. fOK = true;
  1142. pos = m_subrects.GetHeadPosition();
  1143. while(pos)
  1144. {
  1145. SubRect& sr = m_subrects.GetNext(pos);
  1147. if(layer == sr.layer && !(r & sr.r).IsRectEmpty())
  1148. {
  1149. if(fSearchDown)
  1150. {
  1151. r.bottom = sr.r.bottom + r.Height();
  1152. r.top = sr.r.bottom;
  1153. }
  1154. else
  1155. {
  1156. r.top = sr.r.top - r.Height();
  1157. r.bottom = sr.r.top;
  1158. }
  1160. fOK = false;
  1161. }
  1162. }
  1163. }
  1164. while(!fOK);
  1166. SubRect sr;
  1167. sr.r = r;
  1168. sr.segment = segment;
  1169. sr.entry = entry;
  1170. sr.layer = layer;
  1171. m_subrects.AddTail(sr);
  1173. return(sr.r + CRect(0, -s->m_topborder, 0, -s->m_bottomborder));
  1174. }
  1176. // CRenderedTextSubtitle
  1178. CRenderedTextSubtitle::CRenderedTextSubtitle(CCritSec* pLock)
  1179. : ISubPicProviderImpl(pLock)
  1180. {
  1181. m_size = CSize(0, 0);
  1183. if(g_hDC_refcnt == 0) 
  1184. {
  1185. g_hDC = CreateCompatibleDC(NULL);
  1186. SetBkMode(g_hDC, TRANSPARENT); 
  1187. SetTextColor(g_hDC, 0xffffff); 
  1188. SetMapMode(g_hDC, MM_TEXT);
  1189. }
  1191. g_hDC_refcnt++;
  1192. }
  1194. CRenderedTextSubtitle::~CRenderedTextSubtitle()
  1195. {
  1196. Deinit();
  1198. g_hDC_refcnt--;
  1199. if(g_hDC_refcnt == 0) DeleteDC(g_hDC);
  1200. }
  1202. void CRenderedTextSubtitle::Copy(CSimpleTextSubtitle& sts)
  1203. {
  1204. CSimpleTextSubtitle::Copy(sts);
  1206. m_size = CSize(0, 0);
  1208. if(CRenderedTextSubtitle* pRTS = dynamic_cast<CRenderedTextSubtitle*>(&sts))
  1209. {
  1210. m_size = pRTS->m_nSize;
  1211. }
  1212. }
  1214. void CRenderedTextSubtitle::Empty()
  1215. {
  1216. Deinit();
  1218. CSimpleTextSubtitle::Empty();
  1219. }
  1221. void CRenderedTextSubtitle::OnChanged()
  1222. {
  1223. CSimpleTextSubtitle::OnChanged();
  1225. POSITION pos = m_subtitleCache.GetStartPosition();
  1226. while(pos)
  1227. {
  1228. int i;
  1229. CSubtitle* s;
  1230.         m_subtitleCache.GetNextAssoc(pos, i, s);
  1231. delete s;
  1232. }
  1234. m_subtitleCache.RemoveAll();
  1236. m_sla.Empty();
  1237. }
  1239. bool CRenderedTextSubtitle::Init(CSize size, CRect vidrect)
  1240. {
  1241. Deinit();
  1243. m_size = CSize(size.cx*8, size.cy*8);
  1244. m_vidrect = CRect(vidrect.left*8, vidrect.top*8, vidrect.right*8, vidrect.bottom*8);
  1246. m_sla.Empty();
  1248. return(true);
  1249. }
  1251. void CRenderedTextSubtitle::Deinit()
  1252. {
  1253. POSITION pos = m_subtitleCache.GetStartPosition();
  1254. while(pos)
  1255. {
  1256. int i;
  1257. CSubtitle* s;
  1258.         m_subtitleCache.GetNextAssoc(pos, i, s);
  1259. delete s;
  1260. }
  1262. m_subtitleCache.RemoveAll();
  1264. m_sla.Empty();
  1266. m_size = CSize(0, 0);
  1267. m_vidrect.SetRectEmpty();
  1268. }
  1270. void CRenderedTextSubtitle::ParseEffect(CSubtitle* sub, CString str)
  1271. {
  1272. str.Trim();
  1273. if(!sub || str.IsEmpty()) return;
  1275. const TCHAR* s = _tcschr(str, ';');
  1276. if(!s) {s = (LPTSTR)(LPCTSTR)str; s += str.GetLength()-1;}
  1277. s++;
  1278. CString effect = str.Left(s - str);
  1280. if(!effect.CompareNoCase(_T("Banner;")))
  1281. {
  1282. int delay, lefttoright = 0, fadeawaywidth = 0;
  1283. if(_stscanf(s, _T("%d;%d;%d"), &delay, &lefttoright, &fadeawaywidth) < 1) return;
  1285. Effect* e = new Effect;
  1286. if(!e) return;
  1288. sub->m_effects[e->type = EF_BANNER] = e;
  1289. e->param[0] = (int)(max(1.0*delay/sub->m_scalex, 1));
  1290. e->param[1] = lefttoright;
  1291. e->param[2] = (int)(sub->m_scalex*fadeawaywidth);
  1293. sub->m_wrapStyle = 2;
  1294. }
  1295. else if(!effect.CompareNoCase(_T("Scroll up;")) || !effect.CompareNoCase(_T("Scroll down;")))
  1296. {
  1297. int top, bottom, delay, fadeawayheight = 0;
  1298. if(_stscanf(s, _T("%d;%d;%d;%d"), &top, &bottom, &delay, &fadeawayheight) < 3) return;
  1300. if(top > bottom) {int tmp = top; top = bottom; bottom = tmp;}
  1302. Effect* e = new Effect;
  1303. if(!e) return;
  1305. sub->m_effects[e->type = EF_SCROLL] = e;
  1306. e->param[0] = (int)(sub->m_scaley*top*8);
  1307. e->param[1] = (int)(sub->m_scaley*bottom*8);
  1308. e->param[2] = (int)(max(1.0*delay/sub->m_scaley, 1));
  1309. e->param[3] = (effect.GetLength() == 12);
  1310. e->param[4] = (int)(sub->m_scaley*fadeawayheight);
  1311. }
  1312. }
  1314. void CRenderedTextSubtitle::ParseString(CSubtitle* sub, CStringW str, STSStyle& style)
  1315. {
  1316. if(!sub) return;
  1318. str.Replace(L"\N", L"n");
  1319. str.Replace(L"\n", (sub->m_wrapStyle < 2 || sub->m_wrapStyle == 3) ? L" " : L"n");
  1320. str.Replace(L"\h", L"x00A0");
  1322. for(int i = 0, j = 0, len = str.GetLength(); j <= len; j++)
  1323. {
  1324. WCHAR c = str[j];
  1326. if(c != 'n' && c != ' ' && c != 'x00A0' && c != 0)
  1327. continue;
  1329. if(i < j)
  1330. {
  1331. if(CWord* w = new CText(style, str.Mid(i, j-i), m_ktype, m_kstart, m_kend))
  1332. {
  1333. sub->m_words.AddTail(w); 
  1334. m_kstart = m_kend;
  1335. }
  1336. }
  1338. if(c == 'n')
  1339. {
  1340. if(CWord* w = new CText(style, CStringW(), m_ktype, m_kstart, m_kend))
  1341. {
  1342. sub->m_words.AddTail(w); 
  1343. m_kstart = m_kend;
  1344. }
  1345. }
  1346. else if(c == ' ' || c == 'x00A0')
  1347. {
  1348. if(CWord* w = new CText(style, CStringW(c), m_ktype, m_kstart, m_kend))
  1349. {
  1350. sub->m_words.AddTail(w); 
  1351. m_kstart = m_kend;
  1352. }
  1353. }
  1355. i = j+1;
  1356. }
  1358. return;
  1359. }
  1361. void CRenderedTextSubtitle::ParsePolygon(CSubtitle* sub, CStringW str, STSStyle& style)
  1362. {
  1363. if(!sub || !str.GetLength() || !m_nPolygon) return;
  1365. if(CWord* w = new CPolygon(style, str, m_ktype, m_kstart, m_kend, sub->m_scalex/(1<<(m_nPolygon-1)), sub->m_scaley/(1<<(m_nPolygon-1)), m_polygonBaselineOffset))
  1366. {
  1367. sub->m_words.AddTail(w); 
  1368. m_kstart = m_kend;
  1369. }
  1370. }
  1372. bool CRenderedTextSubtitle::ParseSSATag(CSubtitle* sub, CStringW str, STSStyle& style, STSStyle& org, bool fAnimate)
  1373. {
  1374. if(!sub) return(false);
  1376. int nTags = 0, nUnrecognizedTags = 0;
  1378. for(int i = 0, j; (j = str.Find('\', i)) >= 0; i = j)
  1379. {
  1380. CStringW cmd;
  1381. for(WCHAR c = str[++j]; c && c != '(' && c != '\'; cmd += c, c = str[++j]);
  1382. cmd.Trim();
  1383. if(cmd.IsEmpty()) continue;
  1385. CArray<CStringW> params;
  1387. if(str[j] == '(')
  1388. {
  1389. CStringW param;
  1390. for(WCHAR c = str[++j]; c && c != ')'; param += c, c = str[++j]);
  1391. param.Trim();
  1393. while(!param.IsEmpty())
  1394. {
  1395. int i = param.Find(','), j = param.Find('\');
  1397. if(i >= 0 && (j < 0 || i < j))
  1398. {
  1399. CStringW s = param.Left(i).Trim();
  1400. if(!s.IsEmpty()) params.Add(s);
  1401. param = i+1 < param.GetLength() ? param.Mid(i+1) : L"";
  1402. }
  1403. else
  1404. {
  1405. param.Trim();
  1406. if(!param.IsEmpty()) params.Add(param);
  1407. param.Empty();
  1408. }
  1409. }
  1410. }
  1412. if(!cmd.Find(L"1c") || !cmd.Find(L"2c") || !cmd.Find(L"3c") || !cmd.Find(L"4c"))
  1413. params.Add(cmd.Mid(2).Trim(L"&H")), cmd = cmd.Left(2);
  1414. else if(!cmd.Find(L"1a") || !cmd.Find(L"2a") || !cmd.Find(L"3a") || !cmd.Find(L"4a"))
  1415. params.Add(cmd.Mid(2).Trim(L"&H")), cmd = cmd.Left(2);
  1416. else if(!cmd.Find(L"alpha"))
  1417. params.Add(cmd.Mid(5).Trim(L"&H")), cmd = cmd.Left(5);
  1418. else if(!cmd.Find(L"an"))
  1419. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1420. else if(!cmd.Find(L"a"))
  1421. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1422. else if(!cmd.Find(L"bord"))
  1423. params.Add(cmd.Mid(4)), cmd = cmd.Left(4);
  1424. else if(!cmd.Find(L"be"))
  1425. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1426. else if(!cmd.Find(L"b"))
  1427. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1428. else if(!cmd.Find(L"clip"))
  1429. ;
  1430. else if(!cmd.Find(L"c"))
  1431. params.Add(cmd.Mid(1).Trim(L"&H")), cmd = cmd.Left(1);
  1432.         else if(!cmd.Find(L"fade"))
  1433. ;
  1434. else if(!cmd.Find(L"fe"))
  1435. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1436. else if(!cmd.Find(L"fn"))
  1437. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1438. else if(!cmd.Find(L"frx") || !cmd.Find(L"fry") || !cmd.Find(L"frz"))
  1439. params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
  1440. else if(!cmd.Find(L"fr"))
  1441. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1442. else if(!cmd.Find(L"fscx") || !cmd.Find(L"fscy"))
  1443. params.Add(cmd.Mid(4)), cmd = cmd.Left(4);
  1444. else if(!cmd.Find(L"fsc"))
  1445. params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
  1446. else if(!cmd.Find(L"fsp"))
  1447. params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
  1448. else if(!cmd.Find(L"fs"))
  1449. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1450. else if(!cmd.Find(L"i"))
  1451. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1452. else if(!cmd.Find(L"kf") || !cmd.Find(L"ko"))
  1453. params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
  1454. else if(!cmd.Find(L"k") || !cmd.Find(L"K"))
  1455. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1456. else if(!cmd.Find(L"move"))
  1457. ;
  1458. else if(!cmd.Find(L"org"))
  1459. ;
  1460. else if(!cmd.Find(L"pbo"))
  1461. params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
  1462. else if(!cmd.Find(L"pos"))
  1463. ;
  1464. else if(!cmd.Find(L"p"))
  1465. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1466. else if(!cmd.Find(L"q"))
  1467. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1468. else if(!cmd.Find(L"r"))
  1469. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1470. else if(!cmd.Find(L"shad"))
  1471. params.Add(cmd.Mid(4)), cmd = cmd.Left(4);
  1472. else if(!cmd.Find(L"s"))
  1473. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1474. else if(!cmd.Find(L"t"))
  1475. ;
  1476. else if(!cmd.Find(L"u"))
  1477. params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
  1478. else
  1479. nUnrecognizedTags++;
  1481. nTags++;
  1483. // TODO: call ParseStyleModifier(cmd, params, ..) and move the rest there
  1485. CStringW p = params.GetCount() > 0 ? params[0] : L"";
  1487. if(cmd == "1c" || cmd == L"2c" || cmd == L"3c" || cmd == L"4c")
  1488. {
  1489. int i = cmd[0] - '1';
  1491. DWORD c = wcstol(p, NULL, 16);
  1492. style.colors[i] = !p.IsEmpty()
  1493. ? (((int)CalcAnimation(c&0xff, style.colors[i]&0xff, fAnimate))&0xff
  1494.   |((int)CalcAnimation(c&0xff00, style.colors[i]&0xff00, fAnimate))&0xff00
  1495.   |((int)CalcAnimation(c&0xff0000, style.colors[i]&0xff0000, fAnimate))&0xff0000)
  1496. : org.colors[i];
  1497. }
  1498. else if(cmd == L"1a" || cmd == L"2a" || cmd == L"3a" || cmd == L"4a")
  1499. {
  1500. int i = cmd[0] - '1';
  1502. style.alpha[i] = !p.IsEmpty()
  1503. ? (BYTE)CalcAnimation(wcstol(p, NULL, 16), style.alpha[i], fAnimate)
  1504. : org.alpha[i];
  1505. }
  1506. else if(cmd == L"alpha")
  1507. {
  1508. for(int i = 0; i < 4; i++)
  1509. {
  1510. style.alpha[i] = !p.IsEmpty()
  1511. ? (BYTE)CalcAnimation(wcstol(p, NULL, 16), style.alpha[i], fAnimate)
  1512. : org.alpha[i];
  1513. }
  1514. }
  1515. else if(cmd == L"an")
  1516. {
  1517. int n = wcstol(p, NULL, 10);
  1518. if(sub->m_scrAlignment < 0)
  1519.                 sub->m_scrAlignment = (n > 0 && n < 10) ? n : org.scrAlignment;
  1520. }
  1521. else if(cmd == L"a")
  1522. {
  1523. int n = wcstol(p, NULL, 10);
  1524. if(sub->m_scrAlignment < 0)
  1525.                 sub->m_scrAlignment = (n > 0 && n < 12) ? ((((n-1)&3)+1)+((n&4)?6:0)+((n&8)?3:0)) : org.scrAlignment;
  1526. }
  1527. else if(cmd == L"bord")
  1528. {
  1529. double n = CalcAnimation(wcstod(p, NULL), style.outlineWidth, fAnimate);
  1530. style.outlineWidth = !p.IsEmpty()
  1531. ? (n < 0 ? 0 : n)
  1532. : org.outlineWidth;
  1533. }
  1534. else if(cmd == L"be")
  1535. {
  1536. int n = wcstol(p, NULL, 10);
  1537. style.fBlur = !p.IsEmpty()
  1538. ? (n == 0 ? false : n == 1 ? true : org.fBlur)
  1539. : org.fBlur;
  1540. }
  1541. else if(cmd == L"b")
  1542. {
  1543. int n = wcstol(p, NULL, 10);
  1544. style.fontWeight = !p.IsEmpty()
  1545. ? (n == 0 ? FW_NORMAL : n == 1 ? FW_BOLD : n >= 100 ? n : org.fontWeight)
  1546. : org.fontWeight;
  1547. }
  1548. else if(cmd == L"clip")
  1549. {
  1550. if(params.GetCount() == 1 && !sub->m_pClipper)
  1551. {
  1552. sub->m_pClipper = new CClipper(params[0], CSize(m_size.cx>>3, m_size.cy>>3), sub->m_scalex, sub->m_scaley);
  1553. }
  1554. else if(params.GetCount() == 2 && !sub->m_pClipper)
  1555. {
  1556. int scale = max(wcstol(p, NULL, 10), 1);
  1557. sub->m_pClipper = new CClipper(params[1], CSize(m_size.cx>>3, m_size.cy>>3), sub->m_scalex/(1<<(scale-1)), sub->m_scaley/(1<<(scale-1)));
  1558. }
  1559. else if(params.GetCount() == 4)
  1560. {
  1561. sub->m_clip.SetRect(
  1562. (int)CalcAnimation(sub->m_scalex*wcstol(params[0], NULL, 10), sub->m_clip.left, fAnimate),
  1563. (int)CalcAnimation(sub->m_scaley*wcstol(params[1], NULL, 10), sub->m_clip.top, fAnimate),
  1564. (int)CalcAnimation(sub->m_scalex*wcstol(params[2], NULL, 10), sub->m_clip.right, fAnimate),
  1565. (int)CalcAnimation(sub->m_scaley*wcstol(params[3], NULL, 10), sub->m_clip.bottom, fAnimate));
  1566. }
  1567. }
  1568. else if(cmd == L"c")
  1569. {
  1570. DWORD c = wcstol(p, NULL, 16);
  1571. style.colors[0] = !p.IsEmpty()
  1572. ? (((int)CalcAnimation(c&0xff, style.colors[0]&0xff, fAnimate))&0xff
  1573.   |((int)CalcAnimation(c&0xff00, style.colors[0]&0xff00, fAnimate))&0xff00
  1574.   |((int)CalcAnimation(c&0xff0000, style.colors[0]&0xff0000, fAnimate))&0xff0000)
  1575. : org.colors[0];
  1576. }
  1577.         else if(cmd == L"fade" || cmd == L"fad")
  1578. {
  1579. if(params.GetCount() == 7 && !sub->m_effects[EF_FADE])// {fade(a1=param[0], a2=param[1], a3=param[2], t1=t[0], t2=t[1], t3=t[2], t4=t[3])
  1580. {
  1581. if(Effect* e = new Effect)
  1582. {
  1583. for(int i = 0; i < 3; i++)
  1584. e->param[i] = wcstol(params[i], NULL, 10);
  1585. for(int i = 0; i < 4; i++)
  1586. e->t[i] = wcstol(params[3+i], NULL, 10);
  1587.                 
  1588. sub->m_effects[EF_FADE] = e;
  1589. }
  1590. }
  1591. else if(params.GetCount() == 2 && !sub->m_effects[EF_FADE]) // {fad(t1=t[1], t2=t[2])
  1592. {
  1593. if(Effect* e = new Effect)
  1594. {
  1595. e->param[0] = e->param[2] = 0xff;
  1596. e->param[1] = 0x00;
  1597. for(int i = 1; i < 3; i++) 
  1598. e->t[i] = wcstol(params[i-1], NULL, 10);
  1599. e->t[0] = e->t[3] = -1; // will be substituted with "start" and "end"
  1601. sub->m_effects[EF_FADE] = e;
  1602. }
  1603. }
  1604. }
  1605. else if(cmd == L"fe")
  1606. {
  1607. int n = wcstol(p, NULL, 10);
  1608. style.charSet = !p.IsEmpty()
  1609. ? n
  1610. : org.charSet;
  1611. }
  1612. else if(cmd == L"fn")
  1613. {
  1614. style.fontName = (!p.IsEmpty() && p != '0')
  1615. ? CString(p).Trim()
  1616. : org.fontName;
  1617. }
  1618. else if(cmd == L"frx")
  1619. {
  1620. style.fontAngleX = !p.IsEmpty()
  1621. ? CalcAnimation(wcstod(p, NULL), style.fontAngleX, fAnimate)
  1622. : org.fontAngleX;
  1623. }
  1624. else if(cmd == L"fry")
  1625. {
  1626. style.fontAngleY = !p.IsEmpty()
  1627. ? CalcAnimation(wcstod(p, NULL), style.fontAngleY, fAnimate)
  1628. : org.fontAngleY;
  1629. }
  1630. else if(cmd == L"frz" || cmd == L"fr")
  1631. {
  1632. style.fontAngleZ = !p.IsEmpty()
  1633. ? CalcAnimation(wcstod(p, NULL), style.fontAngleZ, fAnimate)
  1634. : org.fontAngleZ;
  1635. }
  1636. else if(cmd == L"fscx")
  1637. {
  1638. double n = CalcAnimation(wcstol(p, NULL, 10), style.fontScaleX, fAnimate);
  1639. style.fontScaleX = !p.IsEmpty()
  1640. ? ((n < 0) ? 0 : n)
  1641. : org.fontScaleX;
  1642. }
  1643. else if(cmd == L"fscy")
  1644. {
  1645. double n = CalcAnimation(wcstol(p, NULL, 10), style.fontScaleY, fAnimate);
  1646. style.fontScaleY = !p.IsEmpty()
  1647. ? ((n < 0) ? 0 : n)
  1648. : org.fontScaleY;
  1649. }
  1650. else if(cmd == L"fsc")
  1651. {
  1652. style.fontScaleX = org.fontScaleX;
  1653. style.fontScaleY = org.fontScaleY;
  1654. }
  1655. else if(cmd == L"fsp")
  1656. {
  1657. style.fontSpacing = !p.IsEmpty()
  1658. ? CalcAnimation(wcstod(p, NULL), style.fontSpacing, fAnimate)
  1659. : org.fontSpacing;
  1660. }
  1661. else if(cmd == L"fs")
  1662. {
  1663. if(!p.IsEmpty())
  1664. {
  1665. if(p[0] == '-' || p[0] == '+')
  1666. {
  1667. double n = CalcAnimation(style.fontSize + style.fontSize*wcstol(p, NULL, 10)/10, style.fontSize, fAnimate);
  1668. style.fontSize = (n > 0) ? n : org.fontSize;
  1669. }
  1670. else
  1671. {
  1672. double n = CalcAnimation(wcstol(p, NULL, 10), style.fontSize, fAnimate);
  1673. style.fontSize = (n > 0) ? n : org.fontSize;
  1674. }
  1675. }
  1676. else
  1677. {
  1678. style.fontSize = org.fontSize;
  1679. }
  1680. }
  1681. else if(cmd == L"i")
  1682. {
  1683. int n = wcstol(p, NULL, 10);
  1684. style.fItalic = !p.IsEmpty()
  1685. ? (n == 0 ? false : n == 1 ? true : org.fItalic)
  1686. : org.fItalic;
  1687. }
  1688. else if(cmd == L"kf" || cmd == L"K")
  1689. {
  1690. m_ktype = 1;
  1691. m_kstart = m_kend;
  1692. m_kend += !p.IsEmpty() 
  1693. ? wcstol(p, NULL, 10)*10
  1694. : 1000;
  1695. }
  1696. else if(cmd == L"ko")
  1697. {
  1698. m_ktype = 2;
  1699. m_kstart = m_kend;
  1700. m_kend += !p.IsEmpty() 
  1701. ? wcstol(p, NULL, 10)*10
  1702. : 1000;
  1703. }
  1704. else if(cmd == L"k")
  1705. {
  1706. m_ktype = 0;
  1707. m_kstart = m_kend;
  1708. m_kend += !p.IsEmpty() 
  1709. ? wcstol(p, NULL, 10)*10
  1710. : 1000;
  1711. }
  1712. else if(cmd == L"move") // {move(x1=param[0], y1=param[1], x2=param[2], y2=param[3][, t1=t[0], t2=t[1]])}
  1713. {
  1714. if((params.GetCount() == 4 || params.GetCount() == 6) && !sub->m_effects[EF_MOVE])
  1715. {
  1716. if(Effect* e = new Effect)
  1717. {
  1718. e->param[0] = (int)(sub->m_scalex*wcstol(params[0], NULL, 10)*8);
  1719. e->param[1] = (int)(sub->m_scaley*wcstol(params[1], NULL, 10)*8);
  1720. e->param[2] = (int)(sub->m_scalex*wcstol(params[2], NULL, 10)*8);
  1721. e->param[3] = (int)(sub->m_scaley*wcstol(params[3], NULL, 10)*8);
  1723. e->t[0] = e->t[1] = -1;
  1725. if(params.GetCount() == 6)
  1726. {
  1727. for(int i = 0; i < 2; i++)
  1728. e->t[i] = wcstol(params[4+i], NULL, 10);
  1729. }
  1731. sub->m_effects[EF_MOVE] = e;
  1732. }
  1733. }
  1734. }
  1735. else if(cmd == L"org") // {org(x=param[0], y=param[1])}
  1736. {
  1737. if(params.GetCount() == 2 && !sub->m_effects[EF_ORG])
  1738. {
  1739. if(Effect* e = new Effect)
  1740. {
  1741. e->param[0] = (int)(sub->m_scalex*wcstol(params[0], NULL, 10)*8);
  1742. e->param[1] = (int)(sub->m_scaley*wcstol(params[1], NULL, 10)*8);
  1744. sub->m_effects[EF_ORG] = e;
  1745. }
  1746. }
  1747. }
  1748. else if(cmd == L"pbo")
  1749. {
  1750. m_polygonBaselineOffset = wcstol(p, NULL, 10);
  1751. }
  1752. else if(cmd == L"pos")
  1753. {
  1754. if(params.GetCount() == 2 && !sub->m_effects[EF_MOVE])
  1755. {
  1756. if(Effect* e = new Effect)
  1757. {
  1758. e->param[0] = e->param[2] = (int)(sub->m_scalex*wcstol(params[0], NULL, 10)*8);
  1759. e->param[1] = e->param[3] = (int)(sub->m_scaley*wcstol(params[1], NULL, 10)*8);
  1760. e->t[0] = e->t[1] = 0;
  1762. sub->m_effects[EF_MOVE] = e;
  1763. }
  1764. }
  1765. }
  1766. else if(cmd == L"p")
  1767. {
  1768. int n = wcstol(p, NULL, 10);
  1769. m_nPolygon = (n <= 0 ? 0 : n);
  1770. }
  1771. else if(cmd == L"q")
  1772. {
  1773. int n = wcstol(p, NULL, 10);
  1774. sub->m_wrapStyle = !p.IsEmpty() && (0 <= n && n <= 3)
  1775. ? n
  1776. : m_defaultWrapStyle;
  1777. }
  1778. else if(cmd == L"r")
  1779. {
  1780. void* val;
  1781. style = (!p.IsEmpty() && m_styles.Lookup(CString(p), val) && val) ? *((STSStyle*)val) : org;
  1782. }
  1783. else if(cmd == L"shad")
  1784. {
  1785. double n = CalcAnimation(wcstod(p, NULL), style.shadowDepth, fAnimate);
  1786. style.shadowDepth = !p.IsEmpty()
  1787. ? (n < 0 ? 0 : n)
  1788. : org.shadowDepth;
  1789. }
  1790. else if(cmd == L"s")
  1791. {
  1792. int n = wcstol(p, NULL, 10);
  1793. style.fStrikeOut = !p.IsEmpty()
  1794. ? (n == 0 ? false : n == 1 ? true : org.fStrikeOut)
  1795. : org.fStrikeOut;
  1796. }
  1797. else if(cmd == L"t") // t([<t1>,<t2>,][<accel>,]<style modifiers>)
  1798. {
  1799. p.Empty();
  1801. m_animStart = m_animEnd = 0;
  1802. m_animAccel = 1;
  1804. if(params.GetCount() == 1)
  1805. {
  1806. p = params[0];
  1807. }
  1808. else if(params.GetCount() == 2)
  1809. {
  1810. m_animAccel = wcstod(params[0], NULL);
  1811. p = params[1];
  1812. }
  1813. else if(params.GetCount() == 3)
  1814. {
  1815. m_animStart = (int)wcstod(params[0], NULL); 
  1816. m_animEnd = (int)wcstod(params[1], NULL);
  1817. p = params[2];
  1818. }
  1819. else if(params.GetCount() == 4)
  1820. {
  1821. m_animStart = wcstol(params[0], NULL, 10); 
  1822. m_animEnd = wcstol(params[1], NULL, 10);
  1823. m_animAccel = wcstod(params[2], NULL);
  1824. p = params[3];
  1825. }
  1827. ParseSSATag(sub, p, style, org, true);
  1829. sub->m_fAnimated = true;
  1830. }
  1831. else if(cmd == L"u")
  1832. {
  1833. int n = wcstol(p, NULL, 10);
  1834. style.fUnderline = !p.IsEmpty()
  1835. ? (n == 0 ? false : n == 1 ? true : org.fUnderline)
  1836. : org.fUnderline;
  1837. }
  1838. }
  1840. // return(nUnrecognizedTags < nTags);
  1841. return(true); // there are ppl keeping coments inside {}, lets make them happy now
  1842. }
  1844. bool CRenderedTextSubtitle::ParseHtmlTag(CSubtitle* sub, CStringW str, STSStyle& style, STSStyle& org)
  1845. {
  1846. if(str.Find(L"!--") == 0)
  1847. return(true);
  1849. bool fClosing = str[0] == '/';
  1850. str.Trim(L" /");
  1852. int i = str.Find(' ');
  1853. if(i < 0) i = str.GetLength();
  1855. CStringW tag = str.Left(i).MakeLower();
  1856. str = str.Mid(i).Trim();
  1858. CArray<CStringW> attribs, params;
  1859. while((i = str.Find('=')) > 0)
  1860. {
  1861. attribs.Add(str.Left(i).Trim().MakeLower());
  1862. str = str.Mid(i+1);
  1863. for(i = 0; _istspace(str[i]); i++);
  1864. str = str.Mid(i);
  1865. if(str[0] == '"') {str = str.Mid(1); i = str.Find('"');}
  1866. else i = str.Find(' ');
  1867. if(i < 0) i = str.GetLength();
  1868. params.Add(str.Left(i).Trim().MakeLower());
  1869. str = str.Mid(i+1);
  1870. }
  1872. if(tag == L"text")
  1873. ;
  1874. else if(tag == L"b" || tag == L"strong")
  1875. style.fontWeight = !fClosing ? FW_BOLD : org.fontWeight;
  1876. else if(tag == L"i" || tag == L"em")
  1877. style.fItalic = !fClosing ? true : org.fItalic;
  1878. else if(tag == L"u")
  1879. style.fUnderline = !fClosing ? true : org.fUnderline;
  1880. else if(tag == L"s" || tag == L"strike" || tag == L"del")
  1881. style.fStrikeOut = !fClosing ? true : org.fStrikeOut;
  1882. else if(tag == L"font")
  1883. {
  1884. if(!fClosing)
  1885. {
  1886. for(i = 0; i < attribs.GetCount(); i++)
  1887. {
  1888. if(params[i].IsEmpty()) continue;
  1890. int nColor = -1;
  1892. if(attribs[i] == L"face")
  1893. {
  1894. style.fontName = params[i];
  1895. }
  1896. else if(attribs[i] == L"size")
  1897. {
  1898. if(params[i][0] == '+')
  1899. style.fontSize += wcstol(params[i], NULL, 10);
  1900. else if(params[i][0] == '-')
  1901. style.fontSize -= wcstol(params[i], NULL, 10);
  1902. else
  1903. style.fontSize = wcstol(params[i], NULL, 10);
  1904. }
  1905. else if(attribs[i] == L"color")
  1906. {
  1907. nColor = 0;
  1908. }
  1909. else if(attribs[i] == L"outline-color")
  1910. {
  1911. nColor = 2;
  1912. }
  1913. else if(attribs[i] == L"outline-level")
  1914. {
  1915. style.outlineWidth = wcstol(params[i], NULL, 10);
  1916. }
  1917. else if(attribs[i] == L"shadow-color")
  1918. {
  1919. nColor = 3;
  1920. }
  1921. else if(attribs[i] == L"shadow-level")
  1922. {
  1923. style.shadowDepth = wcstol(params[i], NULL, 10);
  1924. }
  1926. if(nColor >= 0 && nColor < 4)
  1927. {
  1928. CString key = WToT(params[i]).TrimLeft('#');
  1929. void* val;
  1930. if(g_colors.Lookup(key, val))
  1931. style.colors[nColor] = (DWORD)val;
  1932. else if ((style.colors[nColor] = _tcstol(key, NULL, 16)) == 0)
  1933. style.colors[nColor] = 0x00ffffff;  // default is white
  1934. style.colors[nColor] = ((style.colors[nColor]>>16)&0xff)|((style.colors[nColor]&0xff)<<16)|(style.colors[nColor]&0x00ff00);
  1935. }
  1936. }
  1937. }
  1938. else
  1939. {
  1940. style.fontName = org.fontName;
  1941. style.fontSize = org.fontSize;
  1942. memcpy(style.colors, org.colors, sizeof(style.colors));
  1943. }
  1944. }
  1945. else if(tag == L"k" && attribs.GetCount() == 1 && attribs[0] == L"t")
  1946. {
  1947. m_ktype = 1;
  1948. m_kstart = m_kend;
  1949. m_kend += wcstol(params[0], NULL, 10);
  1950. }
  1951. else 
  1952. return(false);
  1954. return(true);
  1955. }
  1957. double CRenderedTextSubtitle::CalcAnimation(double dst, double src, bool fAnimate)
  1958. {
  1959. int s = m_animStart ? m_animStart : 0;
  1960. int e = m_animEnd ? m_animEnd : m_delay;
  1962. if(fabs(dst-src) >= 0.0001 && fAnimate)
  1963. {
  1964. if(m_time < s) dst = src;
  1965. else if(s <= m_time && m_time < e)
  1966. {
  1967. double t = pow(1.0 * (m_time - s) / (e - s), m_animAccel);
  1968. dst = (1 - t) * src + t * dst;
  1969. }
  1970. // else dst = dst;
  1971. }
  1973. return(dst);
  1974. }
  1976. CSubtitle* CRenderedTextSubtitle::GetSubtitle(int entry)
  1977. {
  1978. CSubtitle* sub;
  1979. if(m_subtitleCache.Lookup(entry, sub)) 
  1980. {
  1981. if(sub->m_fAnimated) {delete sub; sub = NULL;}
  1982. else return(sub);
  1983. }
  1985. sub = new CSubtitle();
  1986. if(!sub) return(NULL);
  1988. CStringW str = GetStrW(entry, true);
  1990. STSStyle stss, orgstss;
  1991. GetStyle(entry, stss);
  1992. orgstss = stss;
  1994. sub->m_clip.SetRect(0, 0, m_size.cx>>3, m_size.cy>>3);
  1995. sub->m_scrAlignment = -stss.scrAlignment;
  1996. sub->m_wrapStyle = m_defaultWrapStyle;
  1997. sub->m_fAnimated = false;
  1998. sub->m_relativeTo = stss.relativeTo;
  2000. sub->m_scalex = m_dstScreenSize.cx > 0 ? 1.0 * (stss.relativeTo == 1 ? m_vidrect.Width() : m_size.cx) / (m_dstScreenSize.cx*8) : 1.0;
  2001. sub->m_scaley = m_dstScreenSize.cy > 0 ? 1.0 * (stss.relativeTo == 1 ? m_vidrect.Height() : m_size.cy) / (m_dstScreenSize.cy*8) : 1.0;
  2003. m_animStart = m_animEnd = 0;
  2004. m_animAccel = 1;
  2005. m_ktype = m_kstart = m_kend = 0;
  2006. m_nPolygon = 0;
  2007. m_polygonBaselineOffset = 0;
  2009. ParseEffect(sub, GetAt(entry).effect);
  2011. while(!str.IsEmpty())
  2012. {
  2013. bool fParsed = false;
  2015. int i;
  2017. if(str[0] == '{' && (i = str.Find(L'}')) > 0)
  2018. {
  2019. if(fParsed = ParseSSATag(sub, str.Mid(1, i-1), stss, orgstss))
  2020. str = str.Mid(i+1);
  2021. }
  2022. else if(str[0] == '<' && (i = str.Find(L'>')) > 0)
  2023. {
  2024. if(fParsed = ParseHtmlTag(sub, str.Mid(1, i-1), stss, orgstss))
  2025. str = str.Mid(i+1);
  2026. }
  2028. if(fParsed)
  2029. {
  2030. i = str.FindOneOf(L"{<");
  2031. if(i < 0) i = str.GetLength();
  2032. if(i == 0) continue;
  2033. }
  2034. else
  2035. {
  2036. i = str.Mid(1).FindOneOf(L"{<");
  2037. if(i < 0) i = str.GetLength()-1;
  2038. i++;
  2039. }
  2041. STSStyle tmp = stss;
  2043. tmp.fontSize = sub->m_scaley*tmp.fontSize*64;
  2044. tmp.fontSpacing = sub->m_scalex*tmp.fontSpacing*64;
  2045. tmp.outlineWidth *= (m_fScaledBAS ? ((sub->m_scalex+sub->m_scaley)/2) : 1) * 8;
  2046. tmp.shadowDepth *= (m_fScaledBAS ? ((sub->m_scalex+sub->m_scaley)/2) : 1) * 8;
  2048. if(m_nPolygon)
  2049. {
  2050. ParsePolygon(sub, str.Left(i), tmp);
  2051. }
  2052. else
  2053. {
  2054. ParseString(sub, str.Left(i), tmp);
  2055. }
  2057. str = str.Mid(i);
  2058. }
  2060. // just a "work-around" solution... in most cases nobody will want to use org together with moving but without rotating the subs
  2061. if(sub->m_effects[EF_ORG] && (sub->m_effects[EF_MOVE] || sub->m_effects[EF_BANNER] || sub->m_effects[EF_SCROLL]))
  2062. sub->m_fAnimated = true;
  2064. sub->m_scrAlignment = abs(sub->m_scrAlignment);
  2066. STSEntry stse = GetAt(entry);
  2067. CRect marginRect = stse.marginRect;
  2068. if(marginRect.left == 0) marginRect.left = orgstss.marginRect.left;
  2069. if(marginRect.top == 0) marginRect.top = orgstss.marginRect.top;
  2070. if(marginRect.right == 0) marginRect.right = orgstss.marginRect.right;
  2071. if(marginRect.bottom == 0) marginRect.bottom = orgstss.marginRect.bottom;
  2072. marginRect.left = (int)(sub->m_scalex*marginRect.left*8);
  2073. marginRect.top = (int)(sub->m_scaley*marginRect.top*8);
  2074. marginRect.right = (int)(sub->m_scalex*marginRect.right*8);
  2075. marginRect.bottom = (int)(sub->m_scaley*marginRect.bottom*8);
  2077. if(stss.relativeTo == 1)
  2078. {
  2079. marginRect.left += m_vidrect.left;
  2080. marginRect.top += m_vidrect.top;
  2081. marginRect.right += m_size.cx - m_vidrect.right;
  2082. marginRect.bottom += m_size.cy - m_vidrect.bottom;
  2083. }
  2085. sub->CreateClippers(m_size);
  2087. sub->MakeLines(m_size, marginRect);
  2089. m_subtitleCache[entry] = sub;
  2091. return(sub);
  2092. }
  2094. //
  2096. STDMETHODIMP CRenderedTextSubtitle::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  2097. {
  2098.     CheckPointer(ppv, E_POINTER);
  2099.     *ppv = NULL;
  2101.     return 
  2102. QI(IPersist)
  2103. QI(ISubStream)
  2104. QI(ISubPicProvider)
  2105. __super::NonDelegatingQueryInterface(riid, ppv);
  2106. }
  2108. // ISubPicProvider
  2110. STDMETHODIMP_(POSITION) CRenderedTextSubtitle::GetStartPosition(REFERENCE_TIME rt, double fps)
  2111. {
  2112. int iSegment = -1;
  2113. SearchSubs((int)(rt/10000), fps, &iSegment, NULL);
  2115. if(iSegment < 0) iSegment = 0;
  2117. return(GetNext((POSITION)iSegment));
  2118. }
  2120. STDMETHODIMP_(POSITION) CRenderedTextSubtitle::GetNext(POSITION pos)
  2121. {
  2122. int iSegment = (int)pos;
  2124. const STSSegment* stss;
  2125. while((stss = GetSegment(iSegment)) && stss->subs.GetSize() == 0)
  2126. iSegment++;
  2128. return(stss ? (POSITION)(iSegment+1) : NULL);
  2129. }
  2131. STDMETHODIMP_(REFERENCE_TIME) CRenderedTextSubtitle::GetStart(POSITION pos, double fps)
  2132. {
  2133. return(10000i64 * TranslateSegmentStart((int)pos-1, fps));
  2134. }
  2136. STDMETHODIMP_(REFERENCE_TIME) CRenderedTextSubtitle::GetStop(POSITION pos, double fps)
  2137. {
  2138. return(10000i64 * TranslateSegmentEnd((int)pos-1, fps));
  2139. }
  2141. STDMETHODIMP_(bool) CRenderedTextSubtitle::IsAnimated(POSITION pos)
  2142. {
  2143. // TODO
  2144. return(true);
  2145. }
  2147. struct LSub {int idx, layer, readorder;};
  2149. static int lscomp(const void* ls1, const void* ls2)
  2150. {
  2151. int ret = ((LSub*)ls1)->layer - ((LSub*)ls2)->layer;
  2152. if(!ret) ret = ((LSub*)ls1)->readorder - ((LSub*)ls2)->readorder;
  2153. return(ret);
  2154. }
  2156. STDMETHODIMP CRenderedTextSubtitle::Render(SubPicDesc& spd, REFERENCE_TIME rt, double fps, RECT& bbox)
  2157. {
  2158. CRect bbox2(0,0,0,0);
  2160. if(m_size != CSize(spd.w*8, spd.h*8) || m_vidrect != CRect(spd.vidrect.left*8, spd.vidrect.top*8, spd.vidrect.right*8, spd.vidrect.bottom*8))
  2161. Init(CSize(spd.w, spd.h), spd.vidrect);
  2163. int t = (int)(rt / 10000);
  2165. int segment;
  2166. const STSSegment* stss = SearchSubs(t, fps, &segment);
  2167. if(!stss) return S_FALSE;
  2169. // clear any cached subs not in the range of +/-30secs measured from the segment's bounds
  2170. {
  2171. POSITION pos = m_subtitleCache.GetStartPosition();
  2172. while(pos)
  2173. {
  2174. int key;
  2175. CSubtitle* value;
  2176. m_subtitleCache.GetNextAssoc(pos, key, value);
  2178. STSEntry& stse = GetAt(key);
  2179. if(stse.end <= (t-30000) || stse.start > (t+30000)) 
  2180. {
  2181. delete value;
  2182. m_subtitleCache.RemoveKey(key);
  2183. pos = m_subtitleCache.GetStartPosition();
  2184. }
  2185. }
  2186. }
  2188. m_sla.AdvanceToSegment(segment, stss->subs);
  2190. CArray<LSub> subs;
  2192. for(int i = 0, j = stss->subs.GetSize(); i < j; i++)
  2193. {
  2194. LSub ls;
  2195. ls.idx = stss->subs[i];
  2196. ls.layer = GetAt(stss->subs[i]).layer;
  2197. ls.readorder = GetAt(stss->subs[i]).readorder;
  2198. subs.Add(ls);
  2199. }
  2201. qsort(subs.GetData(), subs.GetSize(), sizeof(LSub), lscomp);
  2203. for(int i = 0, j = subs.GetSize(); i < j; i++)
  2204. {
  2205. int entry = subs[i].idx;
  2207. STSEntry stse = GetAt(entry);
  2209. {
  2210. int start = TranslateStart(entry, fps);
  2211. m_time = t - start;
  2212. m_delay = TranslateEnd(entry, fps) - start;
  2213. }
  2215. CSubtitle* s = GetSubtitle(entry);
  2216. if(!s) continue;
  2218. CRect clipRect = s->m_clip;
  2219. CRect r = s->m_rect;
  2220. CSize spaceNeeded = r.Size();
  2222. // apply the effects
  2224. bool fPosOverride = false, fOrgOverride = false;
  2226. int alpha = 0x00;
  2228. CPoint org2;
  2230. for(int k = 0; k < EF_NUMBEROFEFFECTS; k++)
  2231. {
  2232. if(!s->m_effects[k]) continue;
  2234. switch(k)
  2235. {
  2236. case EF_MOVE: // {move(x1=param[0], y1=param[1], x2=param[2], y2=param[3], t1=t[0], t2=t[1])}
  2237. {
  2238. CPoint p;
  2239. CPoint p1(s->m_effects[k]->param[0], s->m_effects[k]->param[1]);
  2240. CPoint p2(s->m_effects[k]->param[2], s->m_effects[k]->param[3]);
  2241. int t1 = s->m_effects[k]->t[0];
  2242. int t2 = s->m_effects[k]->t[1];
  2244. if(t2 < t1) {int t = t1; t1 = t2; t2 = t;}
  2246. if(t1 <= 0 && t2 <= 0) {t1 = 0; t2 = m_delay;}
  2248. if(m_time <= t1) p = p1;
  2249. else if(t1 < m_time && m_time < t2)
  2250. {
  2251. double t = 1.0*(m_time-t1)/(t2-t1);
  2252. p.x = (int)((1-t)*p1.x + t*p2.x);
  2253. p.y = (int)((1-t)*p1.y + t*p2.y);
  2254. }
  2255. else p = p2;
  2257. r = CRect(
  2258. CPoint((s->m_scrAlignment%3) == 1 ? p.x : (s->m_scrAlignment%3) == 0 ? p.x - spaceNeeded.cx : p.x - (spaceNeeded.cx+1)/2,
  2259. s->m_scrAlignment <= 3 ? p.y - spaceNeeded.cy : s->m_scrAlignment <= 6 ? p.y - (spaceNeeded.cy+1)/2 : p.y),
  2260. spaceNeeded);
  2262. if(s->m_relativeTo == 1)
  2263. r.OffsetRect(m_vidrect.TopLeft());
  2265. fPosOverride = true;
  2266. }
  2267. break;
  2268. case EF_ORG: // {org(x=param[0], y=param[1])}
  2269. {
  2270. org2 = CPoint(s->m_effects[k]->param[0], s->m_effects[k]->param[1]);
  2272. fOrgOverride = true;
  2273. }
  2274. break;
  2275. case EF_FADE: // {fade(a1=param[0], a2=param[1], a3=param[2], t1=t[0], t2=t[1], t3=t[2], t4=t[3]) or {fad(t1=t[1], t2=t[2])
  2276. {
  2277. int t1 = s->m_effects[k]->t[0];
  2278. int t2 = s->m_effects[k]->t[1];
  2279. int t3 = s->m_effects[k]->t[2];
  2280. int t4 = s->m_effects[k]->t[3];
  2282. if(t1 == -1 && t4 == -1) {t1 = 0; t3 = m_delay-t3; t4 = m_delay;}
  2284. if(m_time < t1) alpha = s->m_effects[k]->param[0];
  2285. else if(m_time >= t1 && m_time < t2)
  2286. {
  2287. double t = 1.0 * (m_time - t1) / (t2 - t1);
  2288. alpha = (int)(s->m_effects[k]->param[0]*(1-t) + s->m_effects[k]->param[1]*t);
  2289. }
  2290. else if(m_time >= t2 && m_time < t3) alpha = s->m_effects[k]->param[1];
  2291. else if(m_time >= t3 && m_time < t4)
  2292. {
  2293. double t = 1.0 * (m_time - t3) / (t4 - t3);
  2294. alpha = (int)(s->m_effects[k]->param[1]*(1-t) + s->m_effects[k]->param[2]*t);
  2295. }
  2296. else if(m_time >= t4) alpha = s->m_effects[k]->param[2];
  2297. }
  2298. break;
  2299. case EF_BANNER: // Banner;delay=param[0][;leftoright=param[1];fadeawaywidth=param[2]]
  2300. {
  2301. int left = s->m_relativeTo == 1 ? m_vidrect.left : 0, 
  2302. right = s->m_relativeTo == 1 ? m_vidrect.right : m_size.cx;
  2304. r.left = !!s->m_effects[k]->param[1] 
  2305. ? (left/*marginRect.left*/ - spaceNeeded.cx) + (int)(m_time*8.0/s->m_effects[k]->param[0])
  2306. : (right /*- marginRect.right*/) - (int)(m_time*8.0/s->m_effects[k]->param[0]);
  2308. r.right = r.left + spaceNeeded.cx;
  2310. clipRect &= CRect(left>>3, clipRect.top, right>>3, clipRect.bottom);
  2312. fPosOverride = true;
  2313. }
  2314. break;
  2315. case EF_SCROLL: // Scroll up/down(toptobottom=param[3]);top=param[0];bottom=param[1];delay=param[2][;fadeawayheight=param[4]]
  2316. {
  2317. r.top = !!s->m_effects[k]->param[3]
  2318. ? s->m_effects[k]->param[0] + (int)(m_time*8.0/s->m_effects[k]->param[2]) - spaceNeeded.cy
  2319. : s->m_effects[k]->param[1] - (int)(m_time*8.0/s->m_effects[k]->param[2]);
  2321. r.bottom = r.top + spaceNeeded.cy;
  2323. CRect cr(0, (s->m_effects[k]->param[0] + 4) >> 3, spd.w, (s->m_effects[k]->param[1] + 4) >> 3);
  2325. if(s->m_relativeTo == 1)
  2326. r.top += m_vidrect.top, 
  2327. r.bottom += m_vidrect.top, 
  2328. cr.top += m_vidrect.top>>3, 
  2329. cr.bottom += m_vidrect.top>>3;
  2331. clipRect &= cr;
  2333. fPosOverride = true;
  2334. }
  2335. break;
  2336. default:
  2337. break;
  2338. }
  2339. }
  2341. if(!fPosOverride && !fOrgOverride && !s->m_fAnimated) 
  2342. r = m_sla.AllocRect(s, segment, entry, stse.layer, m_collisions);
  2344. CPoint org;
  2345. org.x = (s->m_scrAlignment%3) == 1 ? r.left : (s->m_scrAlignment%3) == 2 ? r.CenterPoint().x : r.right;
  2346. org.y = s->m_scrAlignment <= 3 ? r.bottom : s->m_scrAlignment <= 6 ? r.CenterPoint().y : r.top;
  2348. if(!fOrgOverride) org2 = org;
  2350. BYTE* pAlphaMask = s->m_pClipper?s->m_pClipper->m_pAlphaMask:NULL;
  2352. CPoint p, p2(0, r.top);
  2354. POSITION pos;
  2356. p = p2;
  2358. pos = s->GetHeadPosition();
  2359. while(pos) 
  2360. {
  2361. CLine* l = s->GetNext(pos);
  2363. p.x = (s->m_scrAlignment%3) == 1 ? org.x
  2364. : (s->m_scrAlignment%3) == 0 ? org.x - l->m_width
  2365. :    org.x - (l->m_width/2);
  2367. bbox2 |= l->PaintShadow(spd, clipRect, pAlphaMask, p, org2, m_time, alpha);
  2369. p.y += l->m_ascent + l->m_descent;
  2370. }
  2372. p = p2;
  2374. pos = s->GetHeadPosition();
  2375. while(pos) 
  2376. {
  2377. CLine* l = s->GetNext(pos);
  2379. p.x = (s->m_scrAlignment%3) == 1 ? org.x
  2380. : (s->m_scrAlignment%3) == 0 ? org.x - l->m_width
  2381. :    org.x - (l->m_width/2);
  2383. bbox2 |= l->PaintOutline(spd, clipRect, pAlphaMask, p, org2, m_time, alpha);
  2385. p.y += l->m_ascent + l->m_descent;
  2386. }
  2388. p = p2;
  2390. pos = s->GetHeadPosition();
  2391. while(pos) 
  2392. {
  2393. CLine* l = s->GetNext(pos);
  2395. p.x = (s->m_scrAlignment%3) == 1 ? org.x
  2396. : (s->m_scrAlignment%3) == 0 ? org.x - l->m_width
  2397. :    org.x - (l->m_width/2);
  2399. bbox2 |= l->PaintBody(spd, clipRect, pAlphaMask, p, org2, m_time, alpha);
  2401. p.y += l->m_ascent + l->m_descent;
  2402. }
  2403. }
  2405. bbox = bbox2;
  2407. return (subs.GetSize() && !bbox2.IsRectEmpty()) ? S_OK : S_FALSE;
  2408. }
  2410. // IPersist
  2412. STDMETHODIMP CRenderedTextSubtitle::GetClassID(CLSID* pClassID)
  2413. {
  2414. return pClassID ? *pClassID = __uuidof(this), S_OK : E_POINTER;
  2415. }
  2417. // ISubStream
  2419. STDMETHODIMP_(int) CRenderedTextSubtitle::GetStreamCount()
  2420. {
  2421. return(1);
  2422. }
  2424. STDMETHODIMP CRenderedTextSubtitle::GetStreamInfo(int iStream, WCHAR** ppName, LCID* pLCID)
  2425. {
  2426. if(iStream != 0) return E_INVALIDARG;
  2428. if(ppName)
  2429. {
  2430. if(!(*ppName = (WCHAR*)CoTaskMemAlloc((m_name.GetLength()+1)*sizeof(WCHAR))))
  2431. return E_OUTOFMEMORY;
  2433. wcscpy(*ppName, CStringW(m_name));
  2434. }
  2436. if(pLCID)
  2437. {
  2438. *pLCID = 0; // TODO
  2439. }
  2441. return S_OK;
  2442. }
  2444. STDMETHODIMP_(int) CRenderedTextSubtitle::GetStream()
  2445. {
  2446. return(0);
  2447. }
  2449. STDMETHODIMP CRenderedTextSubtitle::SetStream(int iStream)
  2450. {
  2451. return iStream == 0 ? S_OK : E_FAIL;
  2452. }
  2454. STDMETHODIMP CRenderedTextSubtitle::Reload()
  2455. {
  2456. CFileStatus s;
  2457. if(!CFile::GetStatus(m_path, s)) return E_FAIL;
  2458. return !m_path.IsEmpty() && Open(m_path, DEFAULT_CHARSET) ? S_OK : E_FAIL;
  2459. }