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

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

多媒体编程

开发平台：

Visual C++

USFSubtitles.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 "usfsubtitles.h"
  25. #define DeclareNameAndValue(pNode, name, val) 
  26.     CComBSTR name; 
  27.     pNode->get_nodeName(&name); 
  28. name.ToLower(); 
  29. CComVariant val; 
  30.     pNode->get_nodeValue(&val); 
  32. #define BeginEnumAttribs(pNode, pChild, name, value) 
  33. {CComPtr<IXMLDOMNamedNodeMap> pAttribs; 
  34. if(SUCCEEDED(pNode->get_attributes(&pAttribs)) && pAttribs != NULL) 
  35.     { 
  36. CComPtr<IXMLDOMNode> pChild; 
  37.         for(pAttribs->nextNode(&pChild); pChild; pChild = NULL, pAttribs->nextNode(&pChild)) 
  38.         { 
  40. #define EndEnumAttribs }}}
  42. #define BeginEnumChildren(pNode, pChild) 
  43. {CComPtr<IXMLDOMNode> pChild, pNext; 
  44. for(pNode->get_firstChild(&pChild); pChild; pNext = NULL, pChild->get_nextSibling(&pNext), pChild = pNext) 
  45.     { 
  47. #define EndEnumChildren }}
  49. static CStringW GetText(CComPtr<IXMLDOMNode> pNode)
  50. {
  51. CComBSTR bstr;
  52. pNode->get_text(&bstr);
  54. return(CStringW(bstr));
  55. }
  57. static CStringW GetXML(CComPtr<IXMLDOMNode> pNode)
  58. {
  59. CComBSTR bstr;
  60. pNode->get_xml(&bstr);
  61. CStringW str(bstr);
  62. str.Remove('r');
  63. str.Replace('n', ' ');
  64. for(int i = 0; (i = str.Find(L" ", i)) >= 0; )
  65. {
  66. for(++i; i < str.GetLength() && (str[i] == 'n' || str[i] == ' ');)
  67. str.Delete(i);
  68. }
  69. return(str);
  70. }
  72. static CStringW GetAttrib(CStringW attrib, CComPtr<IXMLDOMNode> pNode)
  73. {
  74. CStringW ret;
  76. BeginEnumAttribs(pNode, pChild, name, val)
  77. {
  78. DeclareNameAndValue(pChild, name, val);
  80. if(CStringW(name) == attrib && val.vt == VT_BSTR) // TODO: prepare for other types
  81. {
  82. ret = val.bstrVal;
  83. break;
  84. }
  85. }
  86. EndEnumAttribs
  88. return(ret);
  89. }
  91. static int TimeToInt(CStringW str)
  92. {
  93. CList<CStringW> sl;
  94. int i = 0;
  95. for(CStringW token = str.Tokenize(L":.,", i); !token.IsEmpty(); token = str.Tokenize(L":.,", i))
  96. sl.AddHead(token);
  98. if(sl.GetCount() > 4)
  99. return(-1);
  101. int time = 0;
  103. int mul[4] = {1,1000,60*1000,60*60*1000};
  104. POSITION pos = sl.GetHeadPosition();
  105. for(i = 0; pos; i++)
  106. {
  107. const WCHAR* s = sl.GetNext(pos);
  108. WCHAR* tmp = NULL;
  109. int t = wcstol(s, &tmp, 10);
  110. if(s >= tmp) return(-1);
  111. time += t * mul[i];
  112. }
  114. return(time);
  115. }
  117. static DWORD StringToDWORD(CStringW str)
  118. {
  119. if(str.IsEmpty()) return(0);
  120. if(str[0] == '#') return((DWORD)wcstol(str, NULL, 16));
  121. else return((DWORD)wcstol(str, NULL, 10));
  122. }
  124. static DWORD ColorToDWORD(CStringW str)
  125. {
  126. if(str.IsEmpty()) return(0);
  128. DWORD ret = 0;
  130. if(str[0] == '#')
  131. {
  132. ret = (DWORD)wcstol(str.TrimLeft('#'), NULL, 16);
  133. }
  134. else
  135. {
  136. void* color = NULL;
  137. g_colors.Lookup(CString(str), color);
  138. ret = (DWORD)color;
  139. }
  141. ret = ((ret&0xff)<<16)|(ret&0xff00ff00)|((ret>>16)&0xff);
  143. return(ret);
  144. }
  146. static int TranslateAlignment(CStringW alignment)
  147. {
  148. return
  149. !alignment.CompareNoCase(L"BottomLeft") ? 1 :
  150. !alignment.CompareNoCase(L"BottomCenter") ? 2 :
  151. !alignment.CompareNoCase(L"BottomRight") ? 3 :
  152. !alignment.CompareNoCase(L"MiddleLeft") ? 4 :
  153. !alignment.CompareNoCase(L"MiddleCenter") ? 5 :
  154. !alignment.CompareNoCase(L"MiddleRight") ? 6 :
  155. !alignment.CompareNoCase(L"TopLeft") ? 7 :
  156. !alignment.CompareNoCase(L"TopCenter") ? 8 :
  157. !alignment.CompareNoCase(L"TopRight") ? 9 :
  158. 2;
  159. }
  161. static int TranslateMargin(CStringW margin, int wndsize)
  162. {
  163. int ret = 0;
  165. if(!margin.IsEmpty())
  166. {
  167. ret = wcstol(margin, NULL, 10);
  168. if(margin.Find('%') >= 0) ret = wndsize * ret / 100;
  169. }
  171. return(ret);
  172. }
  174. ////////////////
  176. CUSFSubtitles::CUSFSubtitles()
  177. {
  178. }
  180. CUSFSubtitles::~CUSFSubtitles()
  181. {
  182. }
  184. bool CUSFSubtitles::Read(LPCTSTR fn)
  185. {
  186. VARIANT_BOOL vb;
  187. CComPtr<IXMLDOMDocument> pDoc;
  188. if(FAILED(pDoc.CoCreateInstance(CLSID_DOMDocument))
  189. || FAILED(pDoc->put_async(VARIANT_FALSE))
  190. || FAILED(pDoc->load(CComVariant(fn), &vb)) || vb != VARIANT_TRUE)
  191. return(false);
  193. styles.RemoveAll();
  194. effects.RemoveAll();
  195. texts.RemoveAll();
  197. if(!ParseUSFSubtitles(CComQIPtr<IXMLDOMNode>(pDoc)))
  198. return(false);
  200. POSITION pos = styles.GetHeadPosition();
  201. while(pos)
  202. {
  203. style_t* def = styles.GetNext(pos);
  205. if(def->name.CompareNoCase(L"Default"))
  206. continue;
  208. POSITION pos2 = styles.GetHeadPosition();
  209. while(pos2)
  210. {
  211. style_t* s = styles.GetNext(pos2);
  213. if(!s->name.CompareNoCase(L"Default"))
  214. continue;
  216. if(s->fontstyle.face.IsEmpty()) s->fontstyle.face = def->fontstyle.face;
  217. if(s->fontstyle.size.IsEmpty()) s->fontstyle.size = def->fontstyle.size;
  218. if(s->fontstyle.color[0].IsEmpty()) s->fontstyle.color[0] = def->fontstyle.color[0];
  219. if(s->fontstyle.color[1].IsEmpty()) s->fontstyle.color[1] = def->fontstyle.color[1];
  220. if(s->fontstyle.color[2].IsEmpty()) s->fontstyle.color[2] = def->fontstyle.color[2];
  221. if(s->fontstyle.color[3].IsEmpty()) s->fontstyle.color[3] = def->fontstyle.color[3];
  222. if(s->fontstyle.italic.IsEmpty()) s->fontstyle.italic = def->fontstyle.italic;
  223. if(s->fontstyle.weight.IsEmpty()) s->fontstyle.weight = def->fontstyle.weight;
  224. if(s->fontstyle.underline.IsEmpty()) s->fontstyle.underline = def->fontstyle.underline;
  225. if(s->fontstyle.alpha.IsEmpty()) s->fontstyle.alpha = def->fontstyle.alpha;
  226. if(s->fontstyle.outline.IsEmpty()) s->fontstyle.outline = def->fontstyle.outline;
  227. if(s->fontstyle.shadow.IsEmpty()) s->fontstyle.shadow = def->fontstyle.shadow;
  228. if(s->fontstyle.wrap.IsEmpty()) s->fontstyle.wrap = def->fontstyle.wrap;
  229. if(s->pal.alignment.IsEmpty()) s->pal.alignment = def->pal.alignment;
  230. if(s->pal.relativeto.IsEmpty()) s->pal.relativeto = def->pal.relativeto;
  231. if(s->pal.horizontal_margin.IsEmpty()) s->pal.horizontal_margin = def->pal.horizontal_margin;
  232. if(s->pal.vertical_margin.IsEmpty()) s->pal.vertical_margin = def->pal.vertical_margin;
  233. if(s->pal.rotate[0].IsEmpty()) s->pal.rotate[0] = def->pal.rotate[0];
  234. if(s->pal.rotate[1].IsEmpty()) s->pal.rotate[1] = def->pal.rotate[1];
  235. if(s->pal.rotate[2].IsEmpty()) s->pal.rotate[2] = def->pal.rotate[2];
  236. }
  238. break;
  239. }
  241. pos = texts.GetHeadPosition();
  242. while(pos)
  243. {
  244. text_t* t = texts.GetNext(pos);
  245. if(t->style.IsEmpty()) t->style = L"Default";
  246. }
  248. return(true);
  249. }
  251. bool CUSFSubtitles::ConvertToSTS(CSimpleTextSubtitle& sts)
  252. {
  253. sts.m_name = metadata.language.text;
  254. sts.m_encoding = CTextFile::UTF8;
  255. sts.m_dstScreenSize = CSize(640, 480);
  256. sts.m_fScaledBAS = true;
  257. sts.m_defaultWrapStyle = 1;
  259. // TODO: map metadata.language.code to charset num (windows doesn't have such a function...)
  260. int charSet = DEFAULT_CHARSET; 
  262. POSITION pos = styles.GetHeadPosition();
  263. while(pos)
  264. {
  265. style_t* s = styles.GetNext(pos);
  267. if(!s->name.CompareNoCase(L"Default") && !s->fontstyle.wrap.IsEmpty())
  268. {
  269. sts.m_defaultWrapStyle = 
  270. !s->fontstyle.wrap.CompareNoCase(L"no") ? 2 :
  271. !s->fontstyle.wrap.CompareNoCase(L"auto") ? 1 :
  272. 1;
  273. }
  275. STSStyle* stss = new STSStyle;
  276. if(!stss) continue;
  278. if(!s->pal.horizontal_margin.IsEmpty())
  279. stss->marginRect.left = stss->marginRect.right = TranslateMargin(s->pal.horizontal_margin, sts.m_dstScreenSize.cx);
  280. if(!s->pal.vertical_margin.IsEmpty())
  281. stss->marginRect.top = stss->marginRect.bottom = TranslateMargin(s->pal.vertical_margin, sts.m_dstScreenSize.cy);
  283. stss->scrAlignment = TranslateAlignment(s->pal.alignment);
  285. if(!s->pal.relativeto.IsEmpty()) stss->relativeTo = 
  286. !s->pal.relativeto.CompareNoCase(L"window") ? 0 :
  287. !s->pal.relativeto.CompareNoCase(L"video") ? 1 :
  288. 0;
  290. stss->borderStyle = 0;
  291. if(!s->fontstyle.outline.IsEmpty()) stss->outlineWidth = wcstol(s->fontstyle.outline, NULL, 10);
  292. if(!s->fontstyle.shadow.IsEmpty()) stss->shadowDepth = wcstol(s->fontstyle.shadow, NULL, 10);
  294. for(int i = 0; i < 4; i++)
  295. {
  296. DWORD color = ColorToDWORD(s->fontstyle.color[i]);
  297. int alpha = (BYTE)wcstol(s->fontstyle.alpha, NULL, 10);
  299. stss->colors[i] = color & 0xffffff;
  300. stss->alpha[i] = (BYTE)(color>>24);
  302. stss->alpha[i] = stss->alpha[i] + (255 - stss->alpha[i]) * min(max(alpha, 0), 100) / 100;
  303. }
  305. if(!s->fontstyle.face.IsEmpty()) stss->fontName = s->fontstyle.face;
  306. if(!s->fontstyle.size.IsEmpty()) stss->fontSize = wcstol(s->fontstyle.size, NULL, 10);
  307. if(!s->fontstyle.weight.IsEmpty()) stss->fontWeight = 
  308. !s->fontstyle.weight.CompareNoCase(L"normal") ? FW_NORMAL :
  309. !s->fontstyle.weight.CompareNoCase(L"bold") ? FW_BOLD :
  310. !s->fontstyle.weight.CompareNoCase(L"lighter") ? FW_LIGHT :
  311. !s->fontstyle.weight.CompareNoCase(L"bolder") ? FW_SEMIBOLD :
  312. wcstol(s->fontstyle.weight, NULL, 10);
  313. if(stss->fontWeight == 0) stss->fontWeight = FW_NORMAL;
  314. if(!s->fontstyle.italic.IsEmpty()) stss->fItalic = s->fontstyle.italic.CompareNoCase(L"yes") == 0;
  315. if(!s->fontstyle.underline.IsEmpty()) stss->fUnderline = s->fontstyle.underline.CompareNoCase(L"yes") == 0;
  316. if(!s->pal.rotate[0].IsEmpty()) stss->fontAngleZ = wcstol(s->pal.rotate[0], NULL, 10);
  317. if(!s->pal.rotate[1].IsEmpty()) stss->fontAngleX = wcstol(s->pal.rotate[1], NULL, 10);
  318. if(!s->pal.rotate[2].IsEmpty()) stss->fontAngleY = wcstol(s->pal.rotate[2], NULL, 10);
  320. stss->charSet = charSet;
  322. sts.AddStyle(WToT(s->name), stss);
  323. }
  325. pos = texts.GetHeadPosition();
  326. while(pos)
  327. {
  328. text_t* t = texts.GetNext(pos);
  330. if(!t->pal.alignment.IsEmpty())
  331. {
  332. CStringW s;
  333. s.Format(L"{\an%d}", TranslateAlignment(t->pal.alignment));
  334. t->str = s + t->str;
  335. }
  337. CRect marginRect;
  338. marginRect.SetRectEmpty();
  340. if(!t->pal.horizontal_margin.IsEmpty())
  341. marginRect.left = marginRect.right = TranslateMargin(t->pal.horizontal_margin, sts.m_dstScreenSize.cx);
  342. if(!t->pal.vertical_margin.IsEmpty())
  343. marginRect.top = marginRect.bottom = TranslateMargin(t->pal.vertical_margin, sts.m_dstScreenSize.cy);
  345. WCHAR rtags[3][8] = {L"{\rz%d}", L"{\rx%d}", L"{\ry%d}"};
  346. for(int i = 0; i < 3; i++)
  347. {
  348. if(int angle = wcstol(t->pal.rotate[i], NULL, 10))
  349. {
  350. CStringW str;
  351. str.Format(rtags[i], angle);
  352. t->str = str + t->str;
  353. }
  354. }
  356. if(t->style.CompareNoCase(L"Default") != 0)
  357. {
  358. POSITION pos = styles.GetHeadPosition();
  359. while(pos)
  360. {
  361. style_t* s = styles.GetNext(pos);
  362. if(s->name == t->style && !s->fontstyle.wrap.IsEmpty())
  363. {
  364. int WrapStyle = 
  365. !s->fontstyle.wrap.CompareNoCase(L"no") ? 2 :
  366. !s->fontstyle.wrap.CompareNoCase(L"auto") ? 1 :
  367. 1;
  369. if(WrapStyle != sts.m_defaultWrapStyle)
  370. {
  371. CStringW str;
  372.                         str.Format(L"{\q%d}", WrapStyle);
  373. t->str = str + t->str;
  374. }
  376. break;
  377. }
  378. }
  379. }
  381. // TODO: apply effects as {t(..)} after usf's standard clearly defines them
  383. sts.Add(t->str, true, t->start, t->stop, WToT(t->style), _T(""), _T(""), marginRect);
  384. }
  386. return(true);
  387. }
  389. bool CUSFSubtitles::ParseUSFSubtitles(CComPtr<IXMLDOMNode> pNode)
  390. {
  391. DeclareNameAndValue(pNode, name, val);
  393. if(name == L"usfsubtitles")
  394. {
  395. // metadata
  397. BeginEnumChildren(pNode, pChild)
  398. {
  399. DeclareNameAndValue(pChild, name, val);
  401. if(name == L"metadata")
  402. {
  403. ParseMetadata(pChild, metadata);
  404. }
  405. }
  406. EndEnumChildren
  408. // styles
  410. BeginEnumChildren(pNode, pChild)
  411. {
  412. DeclareNameAndValue(pChild, name, val);
  414. if(name == L"styles")
  415. {
  416. BeginEnumChildren(pChild, pGrandChild) // :)
  417. {
  418. DeclareNameAndValue(pGrandChild, name, val);
  420. if(name == L"style")
  421. {
  422. CAutoPtr<style_t> s(new style_t);
  423. if(s)
  424. {
  425. ParseStyle(pGrandChild, s);
  426. styles.AddTail(s);
  427. }
  428. }
  429. }
  430. EndEnumChildren
  431. }
  432. }
  433. EndEnumChildren
  435. // effects
  437. BeginEnumChildren(pNode, pChild)
  438. {
  439. DeclareNameAndValue(pChild, name, val);
  441. if(name == L"effects")
  442. {
  443. BeginEnumChildren(pChild, pGrandChild) // :)
  444. {
  445. DeclareNameAndValue(pGrandChild, name, val);
  447. if(name == L"effect")
  448. {
  449. CAutoPtr<effect_t> e(new effect_t);
  450. if(e)
  451. {
  452. ParseEffect(pGrandChild, e);
  453. effects.AddTail(e);
  454. }
  455. }
  456. }
  457. EndEnumChildren
  458. }
  459. }
  460. EndEnumChildren
  462. // subtitles
  464. BeginEnumChildren(pNode, pChild)
  465. {
  466. DeclareNameAndValue(pChild, name, val);
  468. if(name == L"subtitles")
  469. {
  470. BeginEnumChildren(pChild, pGrandChild) // :)
  471. {
  472. DeclareNameAndValue(pGrandChild, name, val);
  474. if(name == L"subtitle")
  475. {
  476. CStringW sstart = GetAttrib(L"start", pGrandChild);
  477. CStringW sstop = GetAttrib(L"stop", pGrandChild);
  478. CStringW sduration = GetAttrib(L"duration", pGrandChild);
  479. if(sstart.IsEmpty() || (sstop.IsEmpty() && sduration.IsEmpty()))
  480. continue;
  482. int start = TimeToInt(sstart);
  483. int stop = !sstop.IsEmpty() ? TimeToInt(sstop) : (start + TimeToInt(sduration));
  485. ParseSubtitle(pGrandChild, start, stop);
  486. }
  487. }
  488. EndEnumChildren
  489. }
  490. }
  491. EndEnumChildren
  493. return(true);
  494. }
  496. BeginEnumChildren(pNode, pChild)
  497. {
  498.         if(ParseUSFSubtitles(pChild))
  499. {
  500. return(true);
  501. }
  502. }
  503. EndEnumChildren
  505. return(false);
  506. }
  508. void CUSFSubtitles::ParseMetadata(CComPtr<IXMLDOMNode> pNode, metadata_t& m)
  509. {
  510. DeclareNameAndValue(pNode, name, val);
  512. if(name == L"title")
  513. {
  514. m.title = GetText(pNode);
  515. }
  516. else if(name == L"date")
  517. {
  518. m.date = GetText(pNode);
  519. }
  520. else if(name == L"comment")
  521. {
  522. m.comment = GetText(pNode);
  523. }
  524. else if(name == L"author")
  525. {
  526. BeginEnumChildren(pNode, pChild)
  527. {
  528. DeclareNameAndValue(pChild, name, val);
  530. if(name == L"name")
  531. m.author.name = GetText(pChild);
  532. else if(name == L"email")
  533. m.author.email = GetText(pChild);
  534. else if(name == L"url")
  535. m.author.url = GetText(pChild);
  536. }
  537. EndEnumChildren
  539. return;
  540. }
  541. else if(name == L"language")
  542. {
  543. m.language.text = GetText(pNode);
  544. m.language.code = GetAttrib(L"code", pNode);
  545. }
  546. else if(name == L"languageext")
  547. {
  548. m.languageext.text = GetText(pNode);
  549. m.languageext.code = GetAttrib(L"code", pNode);
  550. }
  552. BeginEnumChildren(pNode, pChild)
  553. {
  554. ParseMetadata(pChild, metadata);
  555. }
  556. EndEnumChildren
  557. }
  559. void CUSFSubtitles::ParseStyle(CComPtr<IXMLDOMNode> pNode, style_t* s)
  560. {
  561. DeclareNameAndValue(pNode, name, val);
  563. if(name == L"style")
  564. {
  565. s->name = GetAttrib(L"name", pNode);
  566. }
  567. else if(name == L"fontstyle")
  568. {
  569. ParseFontstyle(pNode, s->fontstyle);
  570. return;
  571. }
  572. else if(name == L"position")
  573. {
  574. ParsePal(pNode, s->pal);
  575. return;
  576. }
  578. BeginEnumChildren(pNode, pChild)
  579. {
  580. ParseStyle(pChild, s);
  581. }
  582. EndEnumChildren
  583. }
  585. void CUSFSubtitles::ParseFontstyle(CComPtr<IXMLDOMNode> pNode, fontstyle_t& fs)
  586. {
  587. fs.face = GetAttrib(L"face", pNode);
  588. fs.size = GetAttrib(L"size", pNode);
  589. fs.color[0] = GetAttrib(L"color", pNode);
  590. fs.color[1] = GetAttrib(L"back-color", pNode);
  591. fs.color[2] = GetAttrib(L"outline-color", pNode);
  592. fs.color[3] = GetAttrib(L"shadow-color", pNode);
  593. fs.italic = GetAttrib(L"italic", pNode);
  594. fs.weight = GetAttrib(L"weight", pNode);
  595. fs.underline = GetAttrib(L"underline", pNode);
  596. fs.alpha = GetAttrib(L"alpha", pNode);
  597. fs.outline = GetAttrib(L"outline-level", pNode);
  598. fs.shadow = GetAttrib(L"shadow-level", pNode);
  599. fs.wrap = GetAttrib(L"wrap", pNode);
  600. }
  602. void CUSFSubtitles::ParsePal(CComPtr<IXMLDOMNode> pNode, posattriblist_t& pal)
  603. {
  604. pal.alignment = GetAttrib(L"alignment", pNode);
  605. pal.relativeto = GetAttrib(L"relative-to", pNode);
  606. pal.horizontal_margin = GetAttrib(L"horizontal-margin", pNode);
  607. pal.vertical_margin = GetAttrib(L"vertical-margin", pNode);
  608. pal.rotate[0] = GetAttrib(L"rotate-z", pNode);
  609. pal.rotate[1] = GetAttrib(L"rotate-x", pNode);
  610. pal.rotate[2] = GetAttrib(L"rotate-y", pNode);
  611. }
  613. void CUSFSubtitles::ParseEffect(CComPtr<IXMLDOMNode> pNode, effect_t* e)
  614. {
  615. DeclareNameAndValue(pNode, name, val);
  617. if(name == L"effect")
  618. {
  619. e->name = GetAttrib(L"name", pNode);
  620. }
  621. else if(name == L"keyframes")
  622. {
  623. BeginEnumChildren(pNode, pChild)
  624. {
  625. DeclareNameAndValue(pChild, name, val);
  627. if(name == L"keyframe")
  628. {
  629. CAutoPtr<keyframe_t> k(new keyframe_t);
  630. if(k)
  631. {
  632. ParseKeyframe(pChild, k);
  633. e->keyframes.AddTail(k);
  634. }
  635. }
  636. }
  637. EndEnumChildren
  639. return;
  640. }
  642. BeginEnumChildren(pNode, pChild)
  643. {
  644. ParseEffect(pChild, e);
  645. }
  646. EndEnumChildren
  647. }
  649. void CUSFSubtitles::ParseKeyframe(CComPtr<IXMLDOMNode> pNode, keyframe_t* k)
  650. {
  651. DeclareNameAndValue(pNode, name, val);
  653. if(name == L"keyframe")
  654. {
  655. k->position = GetAttrib(L"position", pNode);
  656. }
  657. else if(name == L"fontstyle")
  658. {
  659. ParseFontstyle(pNode, k->fontstyle);
  660. return;
  661. }
  662. else if(name == L"position")
  663. {
  664. ParsePal(pNode, k->pal);
  665. return;
  666. }
  667. }
  669. void CUSFSubtitles::ParseSubtitle(CComPtr<IXMLDOMNode> pNode, int start, int stop)
  670. {
  671. DeclareNameAndValue(pNode, name, val);
  673. if(name == L"text" || name == L"karaoke")
  674. {
  675. CAutoPtr<text_t> t(new text_t);
  676. if(t)
  677. {
  678. t->start = start;
  679. t->stop = stop;
  680. t->style = GetAttrib(L"style", pNode);
  681. t->effect = GetAttrib(L"effect", pNode);
  682. ParsePal(pNode, t->pal);
  683. ParseText(pNode, t->str);
  684. texts.AddTail(t);
  685. }
  687. return;
  688. }
  689. // else if
  691. BeginEnumChildren(pNode, pChild)
  692. {
  693. ParseSubtitle(pChild, start, stop);
  694. }
  695. EndEnumChildren
  696. }
  698. void CUSFSubtitles::ParseText(CComPtr<IXMLDOMNode> pNode, CStringW& str)
  699. {
  700. DeclareNameAndValue(pNode, name, val);
  702. CStringW prefix, postfix;
  704. if(name == L"b")
  705. {
  706. prefix = L"{\b1}";
  707. postfix = L"{\b}";
  708. }
  709. else if(name == L"i")
  710. {
  711. prefix = L"{\i1}";
  712. postfix = L"{\i}";
  713. }
  714. else if(name == L"u")
  715. {
  716. prefix = L"{\u1}";
  717. postfix = L"{\u}";
  718. }
  719. else if(name == L"font")
  720. {
  721. fontstyle_t fs;
  722. ParseFontstyle(pNode, fs);
  724. if(!fs.face.IsEmpty()) {prefix += L"{\fn" + fs.face + L"}"; postfix += L"{\fn}";}
  725. if(!fs.size.IsEmpty()) {prefix += L"{\fs" + fs.size + L"}"; postfix += L"{\fs}";}
  726. if(!fs.outline.IsEmpty()) {prefix += L"{\bord" + fs.outline + L"}"; postfix += L"{\bord}";}
  727. if(!fs.shadow.IsEmpty()) {prefix += L"{\shad" + fs.shadow + L"}"; postfix += L"{\shad}";}
  729. for(int i = 0; i < 4; i++)
  730. {
  731. if(!fs.color[i].IsEmpty())
  732. {
  733. CStringW s;
  734. s.Format(L"{\%dc&H%06x&}", i+1, ColorToDWORD(fs.color[i]));
  735. prefix += s;
  736. s.Format(L"{\%dc}", i+1);
  737. postfix += s;
  738. }
  739. }
  740. }
  741. else if(name == L"k")
  742. {
  743. int t = wcstol(GetAttrib(L"t", pNode), NULL, 10);
  744. CStringW s;
  745. s.Format(L"{\kf%d}", t / 10);
  746. str += s;
  747. return;
  748. }
  749. else if(name == L"br")
  750. {
  751. str += L"\N";
  752. return;
  753. }
  754. else if(name == L"#text")
  755. {
  756. str += GetXML(pNode);
  757. return;
  758. }
  760. BeginEnumChildren(pNode, pChild)
  761. {
  762. CStringW s;
  763. ParseText(pChild, s);
  764. str += s;
  765. }
  766. EndEnumChildren
  768. str = prefix + str + postfix;
  769. }
  771. void CUSFSubtitles::ParseShape(CComPtr<IXMLDOMNode> pNode)
  772. {
  773. // no specs on this yet
  774. }