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

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

多媒体编程

开发平台：

Visual C++

STS.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 "STS.h"
  24. #include <atlbase.h>
  26. // gathered from http://www.netwave.or.jp/~shikai/shikai/shcolor.htm
  28. struct htmlcolor {TCHAR* name; DWORD color;} hmtlcolors[] = 
  29. {
  30. {_T("white"), 0xffffff}, 
  31. {_T("whitesmoke"), 0xf5f5f5}, 
  32. {_T("ghostwhite"), 0xf8f8ff}, 
  33. {_T("snow"), 0xfffafa}, 
  34. {_T("gainsboro"), 0xdcdcdc}, 
  35. {_T("lightgrey"), 0xd3d3d3}, 
  36. {_T("silver"), 0xc0c0c0}, 
  37. {_T("darkgray"), 0xa9a9a9}, 
  38. {_T("gray"), 0x808080}, 
  39. {_T("dimgray"), 0x696969}, 
  40. {_T("lightslategray"), 0x778899}, 
  41. {_T("slategray"), 0x708090}, 
  42. {_T("darkslategray"), 0x2f4f4f}, 
  43. {_T("black"), 0x000000}, 
  45. {_T("azure"), 0xf0ffff}, 
  46. {_T("aliceblue"), 0xf0f8ff}, 
  47. {_T("mintcream"), 0xf5fffa}, 
  48. {_T("honeydew"), 0xf0fff0}, 
  49. {_T("lightcyan"), 0xe0ffff}, 
  50. {_T("paleturqoise"), 0xafeeee}, 
  51. {_T("powderblue"), 0xb0e0e6}, 
  52. {_T("lightblue"), 0xadd8ed}, 
  53. {_T("lightsteelblue"), 0xb0c4de}, 
  54. {_T("skyblue"), 0x87ceeb}, 
  55. {_T("lightskyblue"), 0x87cefa}, 
  56. {_T("cyan"), 0x00ffff}, 
  57. {_T("aqua"), 0x00ff80}, 
  58. {_T("deepskyblue"), 0x00bfff}, 
  59. {_T("aquamarine"), 0x7fffd4}, 
  60. {_T("turquoise"), 0x40e0d0}, 
  61. {_T("darkturquoise"), 0x00ced1}, 
  62. {_T("lightseagreen"), 0x20b2aa}, 
  63. {_T("mediumturquoise"), 0x40e0dd}, 
  64. {_T("mediumaquamarine"), 0x66cdaa}, 
  65. {_T("cadetblue"), 0x5f9ea0}, 
  66. {_T("teal"), 0x008080}, 
  67. {_T("darkcyan"), 0x008b8b}, 
  68. {_T("comflowerblue"), 0x6495ed}, 
  69. {_T("dodgerblue"), 0x1e90ff}, 
  70. {_T("steelblue"), 0x4682b4}, 
  71. {_T("royalblue"), 0x4169e1}, 
  72. {_T("blue"), 0x0000ff}, 
  73. {_T("mediumblue"), 0x0000cd}, 
  74. {_T("mediumslateblue"), 0x7b68ee}, 
  75. {_T("slateblue"), 0x6a5acd}, 
  76. {_T("darkslateblue"), 0x483d8b}, 
  77. {_T("darkblue"), 0x00008b}, 
  78. {_T("midnightblue"), 0x191970}, 
  79. {_T("navy"), 0x000080}, 
  81. {_T("palegreen"), 0x98fb98}, 
  82. {_T("lightgreen"), 0x90ee90}, 
  83. {_T("mediumspringgreen"), 0x00fa9a}, 
  84. {_T("springgreen"), 0x00ff7f}, 
  85. {_T("chartreuse"), 0x7fff00}, 
  86. {_T("lawngreen"), 0x7cfc00}, 
  87. {_T("lime"), 0x00ff00}, 
  88. {_T("limegreen"), 0x32cd32}, 
  89. {_T("greenyellow"), 0xadff2f}, 
  90. {_T("yellowgreen"), 0x9acd32}, 
  91. {_T("darkseagreen"), 0x8fbc8f}, 
  92. {_T("mediumseagreen"), 0x3cb371}, 
  93. {_T("seagreen"), 0x2e8b57}, 
  94. {_T("olivedrab"), 0x6b8e23}, 
  95. {_T("forestgreen"), 0x228b22}, 
  96. {_T("green"), 0x008000}, 
  97. {_T("darkkhaki"), 0xbdb76b}, 
  98. {_T("olive"), 0x808000}, 
  99. {_T("darkolivegreen"), 0x556b2f}, 
  100. {_T("darkgreen"), 0x006400}, 
  101.  
  102. {_T("floralwhite"), 0xfffaf0}, 
  103. {_T("seashell"), 0xfff5ee}, 
  104. {_T("ivory"), 0xfffff0}, 
  105. {_T("beige"), 0xf5f5dc}, 
  106. {_T("cornsilk"), 0xfff8dc}, 
  107. {_T("lemonchiffon"), 0xfffacd}, 
  108. {_T("lightyellow"), 0xffffe0}, 
  109. {_T("lightgoldenrodyellow"), 0xfafad2}, 
  110. {_T("papayawhip"), 0xffefd5}, 
  111. {_T("blanchedalmond"), 0xffedcd}, 
  112. {_T("palegoldenrod"), 0xeee8aa}, 
  113. {_T("khaki"), 0xf0eb8c}, 
  114. {_T("bisque"), 0xffe4c4}, 
  115. {_T("moccasin"), 0xffe4b5}, 
  116. {_T("navajowhite"), 0xffdead}, 
  117. {_T("peachpuff"), 0xffdab9}, 
  118. {_T("yellow"), 0xffff00}, 
  119. {_T("gold"), 0xffd700}, 
  120. {_T("wheat"), 0xf5deb3}, 
  121. {_T("orange"), 0xffa500}, 
  122. {_T("darkorange"), 0xff8c00}, 
  123.  
  124. {_T("oldlace"), 0xfdf5e6}, 
  125. {_T("linen"), 0xfaf0e6}, 
  126. {_T("antiquewhite"), 0xfaebd7}, 
  127. {_T("lightsalmon"), 0xffa07a}, 
  128. {_T("darksalmon"), 0xe9967a}, 
  129. {_T("salmon"), 0xfa8072}, 
  130. {_T("lightcoral"), 0xf08080}, 
  131. {_T("indianred"), 0xcd5c5c}, 
  132. {_T("coral"), 0xff7f50}, 
  133. {_T("tomato"), 0xff6347}, 
  134. {_T("orangered"), 0xff4500}, 
  135. {_T("red"), 0xff0000}, 
  136. {_T("crimson"), 0xdc143c}, 
  137. {_T("firebrick"), 0xb22222}, 
  138. {_T("maroon"), 0x800000}, 
  139. {_T("darkred"), 0x8b0000},
  141. {_T("lavender"), 0xe6e6fe}, 
  142. {_T("lavenderblush"), 0xfff0f5}, 
  143. {_T("mistyrose"), 0xffe4e1}, 
  144. {_T("thistle"), 0xd8bfd8}, 
  145. {_T("pink"), 0xffc0cb}, 
  146. {_T("lightpink"), 0xffb6c1}, 
  147. {_T("palevioletred"), 0xdb7093}, 
  148. {_T("hotpink"), 0xff69b4}, 
  149. {_T("fuchsia"), 0xff00ee}, 
  150. {_T("magenta"), 0xff00ff}, 
  151. {_T("mediumvioletred"), 0xc71585}, 
  152. {_T("deeppink"), 0xff1493}, 
  153. {_T("plum"), 0xdda0dd}, 
  154. {_T("violet"), 0xee82ee}, 
  155. {_T("orchid"), 0xda70d6}, 
  156. {_T("mediumorchid"), 0xba55d3}, 
  157. {_T("mediumpurple"), 0x9370db}, 
  158. {_T("purple"), 0x9370db}, 
  159. {_T("blueviolet"), 0x8a2be2}, 
  160. {_T("darkviolet"), 0x9400d3}, 
  161. {_T("darkorchid"), 0x9932cc}, 
  162.  
  163. {_T("tan"), 0xd2b48c}, 
  164. {_T("burlywood"), 0xdeb887}, 
  165. {_T("sandybrown"), 0xf4a460}, 
  166. {_T("peru"), 0xcd853f}, 
  167. {_T("goldenrod"), 0xdaa520}, 
  168. {_T("darkgoldenrod"), 0xb8860b}, 
  169. {_T("chocolate"), 0xd2691e}, 
  170. {_T("rosybrown"), 0xbc8f8f}, 
  171. {_T("sienna"), 0xa0522d}, 
  172. {_T("saddlebrown"), 0x8b4513}, 
  173. {_T("brown"), 0xa52a2a}, 
  174. };
  176. CHtmlColorMap::CHtmlColorMap()
  177. {
  178. for(int i = 0; i < countof(hmtlcolors); i++)
  179. SetAt(hmtlcolors[i].name, (void*)hmtlcolors[i].color);
  180. }
  182. CHtmlColorMap g_colors;
  184. //
  186. BYTE CharSetList[] =
  187. {
  188. ANSI_CHARSET,
  189. DEFAULT_CHARSET,
  190. SYMBOL_CHARSET,
  191. SHIFTJIS_CHARSET,
  192. HANGEUL_CHARSET,
  193. HANGUL_CHARSET,
  194. GB2312_CHARSET,
  195. CHINESEBIG5_CHARSET,
  196. OEM_CHARSET,
  197. JOHAB_CHARSET,
  198. HEBREW_CHARSET,
  199. ARABIC_CHARSET,
  200. GREEK_CHARSET,
  201. TURKISH_CHARSET,
  202. VIETNAMESE_CHARSET,
  203. THAI_CHARSET,
  204. EASTEUROPE_CHARSET,
  205. RUSSIAN_CHARSET,
  206. MAC_CHARSET,
  207. BALTIC_CHARSET
  208. };
  210. TCHAR* CharSetNames[] = 
  211. {
  212. _T("ANSI"),
  213. _T("DEFAULT"),
  214. _T("SYMBOL"),
  215. _T("SHIFTJIS"),
  216. _T("HANGEUL"),
  217. _T("HANGUL"),
  218. _T("GB2312"),
  219. _T("CHINESEBIG5"),
  220. _T("OEM"),
  221. _T("JOHAB"),
  222. _T("HEBREW"),
  223. _T("ARABIC"),
  224. _T("GREEK"),
  225. _T("TURKISH"),
  226. _T("VIETNAMESE"),
  227. _T("THAI"),
  228. _T("EASTEUROPE"),
  229. _T("RUSSIAN"),
  230. _T("MAC"),
  231. _T("BALTIC"),
  232. };
  234. int CharSetLen = countof(CharSetList);
  236. //
  238. static DWORD CharSetToCodePage(DWORD dwCharSet)
  239. {
  240. CHARSETINFO cs={0};
  241. ::TranslateCharsetInfo((DWORD *)dwCharSet, &cs, TCI_SRCCHARSET);
  242. return cs.ciACP;
  243. }
  245. int FindChar(CStringW str, WCHAR c, int pos, bool fUnicode, int CharSet)
  246. {
  247. if(fUnicode) return(str.Find(c, pos));
  249. int fStyleMod = 0;
  251. DWORD cp = CharSetToCodePage(CharSet);
  252. int OrgCharSet = CharSet;
  254. for(int i = 0, j = str.GetLength(), k; i < j; i++)
  255. {
  256. WCHAR c2 = str[i];
  258. if(IsDBCSLeadByteEx(cp, (BYTE)c2)) i++;
  259. else if(i >= pos)
  260. {
  261. if(c2 == c) return(i);
  262. }
  264. if(c2 == '{') fStyleMod++;
  265. else if(fStyleMod > 0)
  266. {
  267. if(c2 == '}') fStyleMod--;
  268. else if(c2 == 'e' && i >= 3 && i < j-1 && str.Mid(i-2, 3) == L"\fe")
  269. {
  270. CharSet = 0;
  271. for(k = i+1; _istdigit(str[k]); k++) CharSet = CharSet*10 + (str[k] - '0');
  272. if(k == i+1) CharSet = OrgCharSet;
  274. cp = CharSetToCodePage(CharSet);
  275. }
  276. }
  277. }
  279. return(-1);
  280. }
  281. /*
  282. int FindChar(CStringA str, char c, int pos, bool fUnicode, int CharSet)
  283. {
  284. ASSERT(!fUnicode);
  286. return(FindChar(AToW(str), c, pos, false, CharSet));
  287. }
  288. */
  289. static CStringW ToMBCS(CStringW str, DWORD CharSet)
  290. {
  291. CStringW ret;
  293. DWORD cp = CharSetToCodePage(CharSet);
  295. for(int i = 0, j = str.GetLength(); i < j; i++)
  296. {
  297. WCHAR wc = str.GetAt(i);
  298. char c[8];
  300. int len;
  301. if((len = WideCharToMultiByte(cp, 0, &wc, 1, c, 8, NULL, NULL)) > 0)
  302. {
  303. for(int k = 0; k < len; k++)
  304. ret += (WCHAR)(BYTE)c[k];
  305. }
  306. else
  307. {
  308. ret += '?';
  309. }
  310. }
  312. return(ret);
  313. }
  315. static CStringW UnicodeSSAToMBCS(CStringW str, DWORD CharSet)
  316. {
  317. CStringW ret;
  319. int OrgCharSet = CharSet;
  321. for(int j = 0; j < str.GetLength(); )
  322. {
  323. j = str.Find('{', j);
  324. if(j >= 0)
  325. {
  326. ret += ToMBCS(str.Left(j), CharSet);
  327. str = str.Mid(j);
  329. j = str.Find('}');
  330. if(j < 0)
  331. {
  332. ret += ToMBCS(str, CharSet);
  333. break;
  334. }
  335. else
  336. {
  337. int k = str.Find(L"\fe");
  338. if(k >= 0 && k < j)
  339. {
  340. CharSet = 0;
  341. int l = k+3;
  342. for(; _istdigit(str[l]); l++) CharSet = CharSet*10 + (str[l] - '0');
  343. if(l == k+3) CharSet = OrgCharSet;
  344. }
  346. j++;
  348. ret += ToMBCS(str.Left(j), OrgCharSet);
  349. str = str.Mid(j);
  350. j = 0;
  351. }
  352. }
  353. else
  354. {
  355. ret += ToMBCS(str, CharSet);
  356. break;
  357. }
  358. }
  360. return(ret);
  361. }
  363. static CStringW ToUnicode(CStringW str, DWORD CharSet)
  364. {
  365. CStringW ret;
  367. DWORD cp = CharSetToCodePage(CharSet);
  369. for(int i = 0, j = str.GetLength(); i < j; i++)
  370. {
  371. WCHAR wc = str.GetAt(i);
  372. char c = wc&0xff;
  374. if(IsDBCSLeadByteEx(cp, (BYTE)wc))
  375. {
  376. i++;
  378. if(i < j)
  379. {
  380. char cc[2];
  381. cc[0] = c;
  382. cc[1] = (char)str.GetAt(i);
  384. MultiByteToWideChar(cp, 0, cc, 2, &wc, 1);
  385. }
  386. }
  387. else
  388. {
  389. MultiByteToWideChar(cp, 0, &c, 1, &wc, 1);
  390. }
  392. ret += wc;
  393. }
  395. return(ret);
  396. }
  398. static CStringW MBCSSSAToUnicode(CStringW str, int CharSet)
  399. {
  400. CStringW ret;
  402. int OrgCharSet = CharSet;
  404. for(int j = 0; j < str.GetLength(); )
  405. {
  406. j = FindChar(str, '{', 0, false, CharSet);
  408. if(j >= 0)
  409. {
  410. ret += ToUnicode(str.Left(j), CharSet);
  411. str = str.Mid(j);
  413. j = FindChar(str, '}', 0, false, CharSet);
  415. if(j < 0)
  416. {
  417. ret += ToUnicode(str, CharSet);
  418. break;
  419. }
  420. else
  421. {
  422. int k = str.Find(L"\fe");
  423. if(k >= 0 && k < j)
  424. {
  425. CharSet = 0;
  426. int l = k+3;
  427. for(; _istdigit(str[l]); l++) CharSet = CharSet*10 + (str[l] - '0');
  428. if(l == k+3) CharSet = OrgCharSet;
  429. }
  431. j++;
  433. ret += ToUnicode(str.Left(j), OrgCharSet);
  434. str = str.Mid(j);
  435. j = 0;
  436. }
  437. }
  438. else
  439. {
  440. ret += ToUnicode(str, CharSet);
  441. break;
  442. }
  443. }
  445. return(ret);
  446. }
  448. CStringW RemoveSSATags(CStringW str, bool fUnicode, int CharSet)
  449. {
  450. for(int i = 0, j; i < str.GetLength(); )
  451. {
  452. if((i = FindChar(str, '{', i, fUnicode, CharSet)) < 0) break;
  453. if((j = FindChar(str, '}', i, fUnicode, CharSet)) < 0) break;
  454. str.Delete(i, j-i+1);
  455. }
  457. str.Replace(L"\N", L"n");
  458. str.Replace(L"\n", L"n");
  459. str.Replace(L"\h", L" ");
  461. return(str);
  462. }
  464. //
  466. static CStringW SubRipper2SSA(CStringW str, int CharSet)
  467. {
  468. str.Replace(L"<i>", L"{\i1}");
  469. str.Replace(L"</i>", L"{\i}");
  470. str.Replace(L"<b>", L"{\b1}");
  471. str.Replace(L"</b>", L"{\b}");
  472. str.Replace(L"<u>", L"{\u1}");
  473. str.Replace(L"</u>", L"{\u}");
  475. return(str);
  476. }
  478. static bool OpenSubRipper(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  479. {
  480. int num = 0;
  482. CStringW buff;
  483. while(file->ReadString(buff))
  484. {
  485. buff.Trim();
  486. if(buff.IsEmpty()) continue;
  488. WCHAR sep;
  489. int hh1, mm1, ss1, ms1, hh2, mm2, ss2, ms2;
  490. int c = swscanf(buff, L"%d%c%d%c%d%c%d --> %d%c%d%c%d%c%dn", 
  491. &hh1, &sep, &mm1, &sep, &ss1, &sep, &ms1,
  492. &hh2, &sep, &mm2, &sep, &ss2, &sep, &ms2);
  494. if(c == 1) // numbering
  495. {
  496. num = hh1;
  497. }
  498. else if(c == 14) // time info
  499. {
  500. CStringW str, tmp;
  502. bool fFoundEmpty = false;
  504. while(file->ReadString(tmp))
  505. {
  506. tmp.Trim();
  507. if(tmp.IsEmpty()) fFoundEmpty = true;
  509. int num2;
  510. WCHAR c;
  511. if(swscanf(tmp, L"%d%c", &num2, &c) == 1 && fFoundEmpty)
  512. {
  513. num = num2;
  514. break;
  515. }
  517. str += tmp + 'n';
  518. }
  520. ret.Add(
  521. SubRipper2SSA(str, CharSet), 
  522. file->IsUnicode(),
  523. (((hh1*60 + mm1)*60) + ss1)*1000 + ms1, 
  524. (((hh2*60 + mm2)*60) + ss2)*1000 + ms2);
  525. }
  526. else if(c != EOF) // might be another format
  527. {
  528. return(false);
  529. }
  530. }
  532. return(ret.GetCount() > 0);
  533. }
  535. static bool OpenOldSubRipper(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  536. {
  537. CStringW buff;
  538. while(file->ReadString(buff))
  539. {
  540. buff.Trim();
  541. if(buff.IsEmpty()) continue;
  543. for(int i = 0; i < buff.GetLength(); i++)
  544. {
  545. if((i = FindChar(buff, '|', i, file->IsUnicode(), CharSet)) < 0) break;
  546. buff.SetAt(i, 'n');
  547. }
  549. int hh1, mm1, ss1, hh2, mm2, ss2;
  550. int c = swscanf(buff, L"{%d:%d:%d}{%d:%d:%d}", &hh1, &mm1, &ss1, &hh2, &mm2, &ss2);
  552. if(c == 6)
  553. {
  554. ret.Add(
  555. buff.Mid(buff.Find('}', buff.Find('}')+1)+1), 
  556. file->IsUnicode(),
  557. (((hh1*60 + mm1)*60) + ss1)*1000, 
  558. (((hh2*60 + mm2)*60) + ss2)*1000);
  559. }
  560. else if(c != EOF) // might be another format
  561. {
  562. return(false);
  563. }
  564. }
  566. return(ret.GetCount() > 0);
  567. }
  569. static bool OpenSubViewer(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  570. {
  571. STSStyle def;
  572. CStringW font, color, size;
  573. bool fBold, fItalic, fStriked, fUnderline;
  575. CStringW buff;
  576. while(file->ReadString(buff))
  577. {
  578. buff.Trim();
  579. if(buff.IsEmpty()) continue;
  581. if(buff[0] == '[')
  582. {
  583. for(int i = 0; i < buff.GetLength() && buff[i]== '['; )
  584. {
  585. int j = buff.Find(']', ++i);
  586. if(j < i) break;
  588. CStringW tag = buff.Mid(i,j-i);
  589. tag.Trim();
  590. tag.MakeLower();
  592. i += j-i;
  594. j = buff.Find('[', ++i);
  595. if(j < 0) j = buff.GetLength();
  597. CStringW param = buff.Mid(i,j-i);
  598. param.Trim(L" \t,");
  600. i = j;
  602. if(tag == L"font")
  603. font = def.fontName.CompareNoCase(WToT(param)) ? param : L"";
  604. else if(tag == L"colf")
  605. color = def.colors[0] != wcstol(((LPCWSTR)param)+2, 0, 16) ? param : L"";
  606. else if(tag == L"size")
  607. size = def.fontSize != wcstol(param, 0, 10) ? param : L"";
  608. else if(tag == L"style")
  609. {
  610. if(param.Find(L"no") >= 0)
  611. {
  612. fBold = fItalic = fStriked = fUnderline = false;
  613. }
  614. else
  615. {
  616. fBold = def.fontWeight < FW_BOLD && param.Find(L"bd") >= 0;
  617. fItalic = def.fItalic && param.Find(L"it") >= 0;
  618. fStriked = def.fStrikeOut && param.Find(L"st") >= 0;
  619. fUnderline = def.fUnderline && param.Find(L"ud") >= 0;
  620. }
  621. }
  622. }
  624. continue;
  625. }
  627. WCHAR sep;
  628. int hh1, mm1, ss1, hs1, hh2, mm2, ss2, hs2;
  629. int c = swscanf(buff, L"%d:%d:%d%c%d,%d:%d:%d%c%dn", 
  630. &hh1, &mm1, &ss1, &sep, &hs1, &hh2, &mm2, &ss2, &sep, &hs2);
  632. if(c == 10)
  633. {
  634. CStringW str;
  635. file->ReadString(str);
  637. str.Replace(L"[br]", L"\N");
  639. CStringW prefix;
  640. if(!font.IsEmpty()) prefix += L"\fn" + font;
  641. if(!color.IsEmpty()) prefix += L"\c" + color;
  642. if(!size.IsEmpty()) prefix += L"\fs" + size;
  643. if(fBold) prefix += L"\b1";
  644. if(fItalic) prefix += L"\i1";
  645. if(fStriked) prefix += L"\s1";
  646. if(fUnderline) prefix += L"\u1";
  647. if(!prefix.IsEmpty()) str = L"{" + prefix + L"}" + str;
  649. ret.Add(str,
  650. file->IsUnicode(),
  651. (((hh1*60 + mm1)*60) + ss1)*1000 + hs1*10,
  652. (((hh2*60 + mm2)*60) + ss2)*1000 + hs2*10);
  653. }
  654. else if(c != EOF) // might be another format
  655. {
  656. return(false);
  657. }
  658. }
  660. return(ret.GetCount() > 0);
  661. }
  663. static STSStyle* GetMicroDVDStyle(CString str, int CharSet)
  664. {
  665. STSStyle* ret = new STSStyle();
  666. if(!ret) return(NULL);
  668. for(int i = 0, len = str.GetLength(); i < len; i++)
  669. {
  670. int j = str.Find('{', i);
  671. if(j < 0) j = len;
  673. if(j >= len) break;
  675. int k = str.Find('}', j);
  676. if(k < 0) k = len;
  678. CString code = str.Mid(j, k-j);
  679. if(code.GetLength() > 2) code.SetAt(1, (TCHAR)towlower(code[1]));
  681. if(!_tcsnicmp(code, _T("{c:$"), 4))
  682. {
  683. _stscanf(code, _T("{c:$%x"), &ret->colors[0]);
  684. }
  685. else if(!_tcsnicmp(code, _T("{f:"), 3))
  686. {
  687. ret->fontName = code.Mid(3);
  688. }
  689. else if(!_tcsnicmp(code, _T("{s:"), 3))
  690. {
  691. float f;
  692. if(1 == _stscanf(code, _T("{s:%f"), &f))
  693. ret->fontSize = f;
  694. }
  695. else if(!_tcsnicmp(code, _T("{h:"), 3))
  696. {
  697. _stscanf(code, _T("{h:%d"), &ret->charSet);
  698. }
  699. else if(!_tcsnicmp(code, _T("{y:"), 3))
  700. {
  701. code.MakeLower();
  702. if(code.Find('b') >= 0) ret->fontWeight = FW_BOLD;
  703. if(code.Find('i') >= 0) ret->fItalic = true;
  704. if(code.Find('u') >= 0) ret->fUnderline = true;
  705. if(code.Find('s') >= 0) ret->fStrikeOut = true;
  706. }
  707. else if(!_tcsnicmp(code, _T("{p:"), 3))
  708. {
  709. int p;
  710. _stscanf(code, _T("{p:%d"), &p);
  711. ret->scrAlignment = (p == 0) ? 8 : 2;
  712. }
  714. i = k;
  715. }
  717. return(ret);
  718. }
  720. static CStringW MicroDVD2SSA(CStringW str, bool fUnicode, int CharSet)
  721. {
  722. CStringW ret;
  724. enum {COLOR=0, FONTNAME, FONTSIZE, FONTCHARSET, BOLD, ITALIC, UNDERLINE, STRIKEOUT};
  725. bool fRestore[8];
  726. int fRestoreLen = 8;
  727. memset(fRestore, 0, sizeof(bool)*fRestoreLen);
  729. for(int pos = 0, eol; pos < str.GetLength(); pos++)
  730. {
  731. if((eol = FindChar(str, '|', pos, fUnicode, CharSet)) < 0) eol = str.GetLength();
  733. CStringW line = str.Mid(pos, eol-pos);
  735. pos = eol;
  737. for(int i = 0, j, k, len = line.GetLength(); i < len; i++)
  738. {
  739. if((j = FindChar(line, '{', i, fUnicode, CharSet)) < 0) j = str.GetLength();
  741. ret += line.Mid(i, j-i);
  743. if(j >= len) break;
  745. if((k = FindChar(line, '}', j, fUnicode, CharSet)) < 0) k = len;
  747. {
  748. CStringW code = line.Mid(j, k-j);
  750. if(!wcsnicmp(code, L"{c:$", 4))
  751. {
  752. fRestore[COLOR] = (iswupper(code[1]) == 0);
  753. code.MakeLower();
  755. int color;
  756. swscanf(code, L"{c:$%x", &color);
  757. code.Format(L"{\c&H%x&}", color);
  758. ret += code;
  759. }
  760. else if(!wcsnicmp(code, L"{f:", 3))
  761. {
  762. fRestore[FONTNAME] = (iswupper(code[1]) == 0);
  764. code.Format(L"{\fn%s}", code.Mid(3));
  765. ret += code;
  766. }
  767. else if(!wcsnicmp(code, L"{s:", 3))
  768. {
  769. fRestore[FONTSIZE] = (iswupper(code[1]) == 0);
  770. code.MakeLower();
  772. float size;
  773. swscanf(code, L"{s:%f", &size);
  774. code.Format(L"{\fs%f}", size);
  775. ret += code;
  776. }
  777. else if(!wcsnicmp(code, L"{h:", 3))
  778. {
  779. fRestore[COLOR] = (_istupper(code[1]) == 0);
  780. code.MakeLower();
  782. int CharSet;
  783. swscanf(code, L"{h:%d", &CharSet);
  784. code.Format(L"{\fe%d}", CharSet);
  785. ret += code;
  786. }
  787. else if(!wcsnicmp(code, L"{y:", 3))
  788. {
  789. bool f = (_istupper(code[1]) == 0);
  791. code.MakeLower();
  793. ret += '{';
  794. if(code.Find('b') >= 0) {ret += L"\b1"; fRestore[BOLD] = f;}
  795. if(code.Find('i') >= 0) {ret += L"\i1"; fRestore[ITALIC] = f;}
  796. if(code.Find('u') >= 0) {ret += L"\u1"; fRestore[UNDERLINE] = f;}
  797. if(code.Find('s') >= 0) {ret += L"\s1"; fRestore[STRIKEOUT] = f;}
  798. ret += '}';
  799. }
  800. else if(!wcsnicmp(code, L"{o:", 3))
  801. {
  802. code.MakeLower();
  804. int x, y;
  805. TCHAR c;
  806. swscanf(code, L"{o:%d%c%d", &x, &c, &y);
  807. code.Format(L"{\move(%d,%d,0,0,0,0)}", x, y);
  808. ret += code;
  809. }
  810. else ret += code;
  811. }
  813. i = k;
  814. }
  816. if(pos >= str.GetLength()) break;
  818. for(int i = 0; i < fRestoreLen; i++)
  819. {
  820. if(fRestore[i]) 
  821. {
  822. switch(i)
  823. {
  824. case COLOR: ret += L"{\c}"; break;
  825. case FONTNAME: ret += L"{\fn}"; break;
  826. case FONTSIZE: ret += L"{\fs}"; break;
  827. case FONTCHARSET: ret += L"{\fe}"; break;
  828. case BOLD: ret += L"{\b}"; break;
  829. case ITALIC: ret += L"{\i}"; break;
  830. case UNDERLINE: ret += L"{\u}"; break;
  831. case STRIKEOUT: ret += L"{\s}"; break;
  832. default: break;
  833. }
  834. }
  835. }
  837. memset(fRestore, 0, sizeof(bool)*fRestoreLen);
  839. ret += L"\N";
  840. }
  842. return(ret);
  843. }
  845. static bool OpenMicroDVD(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  846. {
  847. bool fCheck = false, fCheck2 = false;
  849. CString style(_T("Default"));
  851. CStringW buff;;
  852. while(file->ReadString(buff))
  853. {
  854. buff.Trim();
  855. if(buff.IsEmpty()) continue;
  857. int start, end;
  858. int c = swscanf(buff, L"{%d}{%d}", &start, &end);
  860. if(c != 2) {c = swscanf(buff, L"{%d}{}", &start)+1; end = start + 60; fCheck = true;}
  862. if(c != 2)
  863. {
  864. int i;
  865. if(buff.Find('{') == 0 && (i = buff.Find('}')) > 1 && i < buff.GetLength())
  866. {
  867. if(STSStyle* s = GetMicroDVDStyle(WToT(buff.Mid(i+1)), CharSet))
  868. {
  869. style = buff.Mid(1, i-1);
  870. style.MakeUpper();
  871. if(style.GetLength()) {CString str = style.Mid(1); str.MakeLower(); style = style.Left(1) + str;}
  872. ret.AddStyle(style, s);
  873. CharSet = s->charSet;
  874. continue;
  875. }
  876. }
  877. }
  879. if(c == 2)
  880. {
  881. if(fCheck2 && ret.GetSize())
  882. {
  883. STSEntry& stse = ret[ret.GetSize()-1];
  884. stse.end = min(stse.end, start);
  885. fCheck2 = false;
  886. }
  888. ret.Add(
  889. MicroDVD2SSA(buff.Mid(buff.Find('}', buff.Find('}')+1)+1), file->IsUnicode(), CharSet), 
  890. file->IsUnicode(),
  891. start, end, 
  892. style);
  894. if(fCheck) 
  895. {
  896. fCheck = false;
  897. fCheck2 = true;
  898. }
  899. }
  900. else if(c != EOF) // might be another format
  901. {
  902. return(false);
  903. }
  904. }
  906. return(ret.GetCount() > 0);
  907. }
  909. static void ReplaceNoCase(CStringW& str, CStringW from, CStringW to)
  910. {
  911. CStringW lstr = str;
  912. lstr.MakeLower();
  914. int i, j, k;
  916. for(i = 0, j = str.GetLength(); i < j; )
  917. {
  918. if((k = lstr.Find(from, i)) >= 0) 
  919. {
  920. str.Delete(k, from.GetLength()); lstr.Delete(k, from.GetLength());
  921. str.Insert(k, to); lstr.Insert(k, to);
  922. i = k + to.GetLength();
  923. j = str.GetLength();
  924. }
  925. else break;
  926. }
  927. }
  929. static CStringW SMI2SSA(CStringW str, int CharSet)
  930. {
  931. ReplaceNoCase(str, L"&nbsp;", L" ");
  932. ReplaceNoCase(str, L"&quot;", L""");
  933. ReplaceNoCase(str, L"<br>", L"\N");
  934. ReplaceNoCase(str, L"<i>", L"{\i1}");
  935. ReplaceNoCase(str, L"</i>", L"{\i}");
  936. ReplaceNoCase(str, L"<b>", L"{\b1}");
  937. ReplaceNoCase(str, L"</b>", L"{\b}");
  939. CStringW lstr = str;
  940. lstr.MakeLower();
  942. // maven@maven.de
  943. // now parse line
  944. for(int i = 0, j = str.GetLength(); i < j; )
  945. {
  946. int k;
  947. if((k = lstr.Find('<', i)) < 0) break;
  949. int chars_inserted = 0;
  951. int l = 1;
  952. for(; k+l < j && lstr[k+l] != '>'; l++);
  953. l++;
  955. // Modified by Cookie Monster 
  956. if (lstr.Find(L"<font ", k) == k)
  957. {
  958. CStringW args = lstr.Mid(k+6, l-6); // delete "<font "
  959. CStringW arg ;
  961. args.Remove('"'); args.Remove('#'); // may include 2 * " + #
  962. arg.TrimLeft(); arg.TrimRight(L" >");
  964. for (;;)
  965. {
  966. args.TrimLeft();
  967. arg = args.SpanExcluding(L" t>");
  968. args = args.Mid(arg.GetLength());
  970. if(arg.IsEmpty())
  971. break;
  972. if (arg.Find(L"color=") == 0 )
  973. {
  974. DWORD color;
  976. arg = arg.Mid(6); // delete "color="
  977. if ( arg.IsEmpty())
  978. continue;
  980. CString key = WToT(arg);
  981. void* val;
  982. if(g_colors.Lookup(key, val))
  983. color = (DWORD)val;
  984. else if ( (color = wcstol(arg, NULL, 16) ) == 0 )
  985. color = 0x00ffffff;  // default is white
  987. arg.Format(L"%02x%02x%02x", color&0xff, (color>>8)&0xff, (color>>16)&0xff);
  988. lstr.Insert(k + l + chars_inserted, CStringW(L"{\c&H") + arg + L"&}");
  989. str.Insert(k + l + chars_inserted, CStringW(L"{\c&H") + arg + L"&}");
  990. chars_inserted += 5 + arg.GetLength() + 2;
  991. }
  992. /*
  993. else if (arg.Find(_T("size=" )) == 0 )
  994. {
  995. uint fsize;
  997. arg = arg.Mid(5); // delete "size="
  998. if ( arg.GetLength() == 0)
  999. continue;
  1001. if ( fsize = _tcstol(arg, &tmp, 10) == 0 )
  1002. continue;
  1004. lstr.Insert(k + l + chars_inserted, CString(_T("{\fs")) + arg + _T("&}"));
  1005. str.Insert(k + l + chars_inserted, CString(_T("{\fs")) + arg + _T("&}"));
  1006. chars_inserted += 4 + arg.GetLength() + 2;
  1007. }
  1008. */
  1009. }
  1010. }
  1012. // Original Code
  1013. /*
  1014. if (lstr.Find(L"<font color=", k) == k)
  1015. {
  1016. CStringW arg = lstr.Mid(k+12, l-12); // may include 2 * " + #
  1018. arg.Remove('"');
  1019. arg.Remove('#');
  1020. arg.TrimLeft(); arg.TrimRight(L" >");
  1022. if(arg.GetLength() > 0)
  1023. {
  1024. DWORD color;
  1026. CString key = WToT(arg);
  1027. void* val;
  1028. if(g_colors.Lookup(key, val)) color = (DWORD)val;
  1029. else color = wcstol(arg, NULL, 16);
  1031. arg.Format(L"%02x%02x%02x", color&0xff, (color>>8)&0xff, (color>>16)&0xff);
  1032. }
  1034. lstr.Insert(k + l + chars_inserted, L"{\c&H" + arg + L"&}");
  1035. str.Insert(k + l + chars_inserted, L"{\c&H" + arg + L"&}");
  1036. chars_inserted += 5 + arg.GetLength() + 2;
  1037. }
  1038. */
  1039. else if (lstr.Find(L"</font>", k) == k)
  1040. {
  1041. lstr.Insert(k + l + chars_inserted, L"{\c}");
  1042. str.Insert(k + l + chars_inserted, L"{\c}");
  1043. chars_inserted += 4;
  1044. }
  1046. str.Delete(k, l); lstr.Delete(k, l);
  1047. i = k + chars_inserted;
  1048. j = str.GetLength();
  1049. }
  1051. return(str);
  1052. }
  1054. static bool OpenSami(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  1055. {
  1056. CStringW buff, caption;
  1058. ULONGLONG pos = file->GetPosition();
  1060. bool fSAMI = false;
  1062. while(file->ReadString(buff) && !fSAMI)
  1063. {
  1064. if(buff.MakeUpper().Find(L"<SAMI>") >= 0) fSAMI = true;
  1065. }
  1067. if(!fSAMI) return(false);
  1069. file->Seek(pos, 0);
  1071. bool fComment = false;
  1073. int start_time = 0;
  1075. while(file->ReadString(buff))
  1076. {
  1077. buff.Trim();
  1078. if(buff.IsEmpty()) continue;
  1080. CStringW ubuff = buff;
  1081. ubuff.MakeUpper();
  1083. if(ubuff.Find(L"<!--") >= 0 || ubuff.Find(L"<TITLE>") >= 0)
  1084. fComment = true;
  1086. if(!fComment)
  1087. {
  1088. int i;
  1090. if((i = ubuff.Find(L"<SYNC START=")) >= 0)
  1091. {
  1092. int time = 0;
  1094. for(i = 12; i < ubuff.GetLength(); i++)
  1095. {
  1096. if(ubuff[i] != '>' && ubuff[i] != 'M')
  1097. {
  1098. if(iswdigit(ubuff[i]))
  1099. {
  1100. time *= 10;
  1101. time += ubuff[i] - 0x30;
  1102. }
  1103. }
  1104. else break;
  1105. }
  1107. ret.Add(
  1108. SMI2SSA(caption, CharSet), 
  1109. file->IsUnicode(),
  1110. start_time, time);
  1112. start_time = time;
  1113. caption.Empty();
  1114. }
  1116. caption += buff;
  1117. }
  1119. if(ubuff.Find(L"-->") >= 0 || ubuff.Find(L"</TITLE>") >= 0)
  1120. fComment = false;
  1121. }
  1123. ret.Add(
  1124. SMI2SSA(caption, CharSet), 
  1125. file->IsUnicode(),
  1126. start_time, MAXLONG);
  1128. return(true);
  1129. }
  1131. static bool OpenVPlayer(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  1132. {
  1133. CStringW buff;
  1134. while(file->ReadString(buff))
  1135. {
  1136. buff.Trim();
  1137. if(buff.IsEmpty()) continue;
  1139. for(int i = 0; i < buff.GetLength(); i++)
  1140. {
  1141. if((i = FindChar(buff, '|', i, file->IsUnicode(), CharSet)) < 0) break;
  1142. buff.SetAt(i, 'n');
  1143. }
  1145. int hh, mm, ss;
  1146. int c = swscanf(buff, L"%d:%d:%d:", &hh, &mm, &ss);
  1148. if(c == 3)
  1149. {
  1150. CStringW str = buff.Mid(buff.Find(':', buff.Find(':', buff.Find(':')+1)+1)+1);
  1151. ret.Add(str, 
  1152. file->IsUnicode(),
  1153. (((hh*60 + mm)*60) + ss)*1000, 
  1154. (((hh*60 + mm)*60) + ss)*1000 + 1000 + 50*str.GetLength());
  1155. }
  1156. else if(c != EOF) // might be another format
  1157. {
  1158. return(false);
  1159. }
  1160. }
  1162. return(ret.GetCount() > 0);
  1163. }
  1165. CStringW GetStr(CStringW& buff, char sep = ',') //throw(...)
  1166. {
  1167. buff.TrimLeft();
  1169. int pos = buff.Find(sep);
  1170. if(pos < 0) 
  1171. {
  1172. pos = buff.GetLength();
  1173. if(pos < 1) throw 1;
  1174. }
  1176. CStringW ret = buff.Left(pos);
  1177. if(pos < buff.GetLength()) buff = buff.Mid(pos+1);
  1179. return(ret);
  1180. }
  1182. int GetInt(CStringW& buff, char sep = ',') //throw(...) 
  1183. {
  1184. CStringW str;
  1186. str = GetStr(buff, sep);
  1187. str.MakeLower();
  1189. CStringW fmtstr = str.GetLength() > 2 && (str.Left(2) == L"&h" || str.Left(2) == L"0x")
  1190. ? str = str.Mid(2), L"%x"
  1191. : L"%d";
  1193. int ret;
  1194. if(swscanf(str, fmtstr, &ret) != 1) throw 1;
  1196. return(ret);
  1197. }
  1199. double GetFloat(CStringW& buff, char sep = ',') //throw(...) 
  1200. {
  1201. CStringW str;
  1203. str = GetStr(buff, sep);
  1204. str.MakeLower();
  1206. float ret;
  1207. if(swscanf(str, L"%f", &ret) != 1) throw 1;
  1209. return((double)ret);
  1210. }
  1212. static bool LoadFont(CString& font)
  1213. {
  1214. int len = font.GetLength();
  1216. CAutoVectorPtr<BYTE> pData;
  1217. if(len == 0 || (len&3) == 1 || !pData.Allocate(len))
  1218. return(false);
  1220. const TCHAR* s = font;
  1221. const TCHAR* e = s + len;
  1222. for(BYTE* p = pData; s < e; s++, p++) *p = *s - 33;
  1224. for(int i = 0, j = 0, k = len&~3; i < k; i+=4, j+=3)
  1225. {
  1226. pData[j+0] = ((pData[i+0]&63)<<2)|((pData[i+1]>>4)& 3);
  1227. pData[j+1] = ((pData[i+1]&15)<<4)|((pData[i+2]>>2)&15);
  1228. pData[j+2] = ((pData[i+2]& 3)<<6)|((pData[i+3]>>0)&63);
  1229. }
  1231. int datalen = (len&~3)*3/4;
  1233. if((len&3) == 2)
  1234. {
  1235. pData[datalen++] = ((pData[(len&~3)+0]&63)<<2)|((pData[(len&~3)+1]>>4)&3);
  1236. }
  1237. else if((len&3) == 3)
  1238. {
  1239. pData[datalen++] = ((pData[(len&~3)+0]&63)<<2)|((pData[(len&~3)+1]>>4)& 3);
  1240. pData[datalen++] = ((pData[(len&~3)+1]&15)<<4)|((pData[(len&~3)+2]>>2)&15);
  1241. }
  1243. HANDLE hFont = INVALID_HANDLE_VALUE;
  1245. if(HMODULE hModule = LoadLibrary(_T("GDI32.DLL")))
  1246. {
  1247. typedef HANDLE (WINAPI *PAddFontMemResourceEx)( IN PVOID, IN DWORD, IN PVOID , IN DWORD*);
  1248. if(PAddFontMemResourceEx f = (PAddFontMemResourceEx)GetProcAddress(hModule, "AddFontMemResourceEx"))
  1249. {
  1250. DWORD cFonts;
  1251. hFont = f(pData, datalen, NULL, &cFonts);
  1252. }
  1254. FreeLibrary(hModule);
  1255. }
  1257. if(hFont == INVALID_HANDLE_VALUE)
  1258. {
  1259. TCHAR path[MAX_PATH];
  1260. GetTempPath(MAX_PATH, path);
  1262. DWORD chksum = 0;
  1263. for(int i = 0, j = datalen>>2; i < j; i++)
  1264. chksum += ((DWORD*)(BYTE*)pData)[i];
  1266. CString fn;
  1267. fn.Format(_T("%sfont%08x.ttf"), path, chksum);
  1269. CFileStatus fs;
  1270. if(!CFileGetStatus(fn, fs))
  1271. {
  1272. CFile f;
  1273. if(f.Open(fn, CFile::modeCreate|CFile::modeWrite|CFile::typeBinary|CFile::shareDenyWrite))
  1274. {
  1275. f.Write(pData, datalen);
  1276. f.Close();
  1277. }
  1278. }
  1280. AddFontResource(fn);
  1281. }
  1283. return(true);
  1284. }
  1286. static bool LoadUUEFont(CTextFile* file)
  1287. {
  1288. CString s, font;
  1289. while(file->ReadString(s))
  1290. {
  1291. s.Trim();
  1292. if(s.IsEmpty() || s[0] == '[') break;
  1293. if(s.Find(_T("fontname:")) == 0) {LoadFont(font); font.Empty(); continue;}
  1295. font += s;
  1296. }
  1298. if(!font.IsEmpty())
  1299. LoadFont(font);
  1301. return(true);
  1302. }
  1304. static bool OpenSubStationAlpha(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  1305. {
  1306. bool fRet = false;
  1308. int version = 3, sver = 3;
  1310. CStringW buff;
  1311. while(file->ReadString(buff))
  1312. {
  1313. buff.Trim();
  1314. if(buff.IsEmpty() || buff.GetAt(0) == ';') continue;
  1316. CStringW entry;
  1318. // try {
  1319. entry = GetStr(buff, ':');
  1320. // }
  1321. // catch(...) {continue;}
  1323. entry.MakeLower();
  1325. if(entry == L"[script info]")
  1326. {
  1327. fRet = true;
  1328. }
  1329. else if(entry == L"playresx")
  1330. {
  1331. try {ret.m_dstScreenSize.cx = GetInt(buff);}
  1332. catch(...) {ret.m_dstScreenSize = CSize(0, 0); return(false);}
  1334. if(ret.m_dstScreenSize.cy <= 0)
  1335. {
  1336. ret.m_dstScreenSize.cy = (ret.m_dstScreenSize.cx == 1280)
  1337. ? 1024 
  1338. : ret.m_dstScreenSize.cx * 3 / 4;
  1339. }
  1340. }
  1341. else if(entry == L"playresy")
  1342. {
  1343. try {ret.m_dstScreenSize.cy = GetInt(buff);}
  1344. catch(...) {ret.m_dstScreenSize = CSize(0, 0); return(false);}
  1346. if(ret.m_dstScreenSize.cx <= 0)
  1347. {
  1348. ret.m_dstScreenSize.cx = (ret.m_dstScreenSize.cy == 1024)
  1349. ? 1280 
  1350. : ret.m_dstScreenSize.cy * 4 / 3;
  1351. }
  1352. }
  1353. else if(entry == L"wrapstyle")
  1354. {
  1355. try {ret.m_defaultWrapStyle = GetInt(buff);}
  1356. catch(...) {ret.m_defaultWrapStyle = 1; return(false);}
  1357. }
  1358. else if(entry == L"scripttype")
  1359. {
  1360. if(buff.GetLength() >= 4 && !buff.Right(4).CompareNoCase(L"4.00")) version = sver = 4;
  1361. else if(buff.GetLength() >= 5 && !buff.Right(5).CompareNoCase(L"4.00+")) version = sver = 5;
  1362. }
  1363. else if(entry == L"collisions")
  1364. {
  1365. buff = GetStr(buff);
  1366. buff.MakeLower();
  1367. ret.m_collisions = buff.Find(L"reverse") >= 0 ? 1 : 0;
  1368. }
  1369. else if(entry == L"scaledborderandshadow")
  1370. {
  1371. buff = GetStr(buff);
  1372. buff.MakeLower();
  1373. ret.m_fScaledBAS = buff.Find(L"yes") >= 0;
  1374. }
  1375. else if(entry == L"[v4 styles]")
  1376. {
  1377. fRet = true;
  1378.             sver = 4;
  1379. }
  1380. else if(entry == L"[v4+ styles]")
  1381. {
  1382. fRet = true;
  1383.             sver = 5;
  1384. }
  1385. else if(entry == L"style")
  1386. {
  1387. STSStyle* style = new STSStyle;
  1388. if(!style) return(false);
  1390. try 
  1391. {
  1392. CString StyleName;
  1393. int alpha;
  1395. StyleName = WToT(GetStr(buff));
  1396. style->fontName = WToT(GetStr(buff));
  1397. style->fontSize = GetFloat(buff);
  1398. for(int i = 0; i < 4; i++) style->colors[i] = (COLORREF)GetInt(buff);
  1399. style->fontWeight = !!GetInt(buff) ? FW_BOLD : FW_NORMAL;
  1400. style->fItalic = !!GetInt(buff);
  1401. if(sver >= 5) style->fUnderline = !!GetInt(buff);
  1402. if(sver >= 5) style->fStrikeOut = !!GetInt(buff);
  1403. if(sver >= 5) style->fontScaleX = GetFloat(buff);
  1404. if(sver >= 5) style->fontScaleY = GetFloat(buff);
  1405. if(sver >= 5) style->fontSpacing = GetFloat(buff);
  1406. if(sver >= 5) style->fontAngleZ = GetFloat(buff);
  1407. if(sver >= 4) style->borderStyle = GetInt(buff);
  1408. style->outlineWidth = GetFloat(buff);
  1409. style->shadowDepth = GetFloat(buff);
  1410. style->scrAlignment = GetInt(buff);
  1411. style->marginRect.left = GetInt(buff);
  1412. style->marginRect.right = GetInt(buff);
  1413. style->marginRect.top = style->marginRect.bottom = GetInt(buff);
  1414. if(sver <= 4) alpha = GetInt(buff);
  1415. style->charSet = GetInt(buff);
  1417. if(sver <= 4) style->colors[2] = style->colors[3]; // style->colors[2] is used for drawing the outline
  1418. if(sver <= 4) alpha = max(min(alpha, 0xff), 0);
  1419. if(sver <= 4) {for(int i = 0; i < 3; i++) style->alpha[i] = alpha; style->alpha[3] = 0x80;}
  1420. if(sver >= 5) for(int i = 0; i < 4; i++) {style->alpha[i] = (BYTE)(style->colors[i]>>24); style->colors[i] &= 0xffffff;}
  1421. if(sver >= 5) style->fontScaleX = max(style->fontScaleX, 0);
  1422. if(sver >= 5) style->fontScaleY = max(style->fontScaleY, 0);
  1423. if(sver >= 5) style->fontSpacing = max(style->fontSpacing, 0);
  1424. style->fontAngleX = style->fontAngleY = 0;
  1425. style->borderStyle = style->borderStyle == 1 ? 0 : style->borderStyle == 3 ? 1 : 0;
  1426. style->outlineWidth = max(style->outlineWidth, 0);
  1427. style->shadowDepth = max(style->shadowDepth, 0);
  1428. if(sver <= 4) style->scrAlignment = (style->scrAlignment&4) ? ((style->scrAlignment&3)+6) // top
  1429. : (style->scrAlignment&8) ? ((style->scrAlignment&3)+3) // mid
  1430. : (style->scrAlignment&3); // bottom
  1432. StyleName.TrimLeft('*');
  1434. ret.AddStyle(StyleName, style);
  1435. }
  1436. catch(...)
  1437. {
  1438. delete style;
  1439. return(false);
  1440. }
  1441. }
  1442. else if(entry == L"[events]")
  1443. {
  1444. fRet = true;
  1445. }
  1446. else if(entry == _T("dialogue"))
  1447. {
  1448. try
  1449. {
  1450. int hh1, mm1, ss1, ms1_div10, hh2, mm2, ss2, ms2_div10, layer = 0;
  1451. CString Style, Actor, Effect;
  1452. CRect marginRect;
  1454. if(version <= 4){GetStr(buff, '='); GetInt(buff);} /* Marked = */
  1455. if(version >= 5)layer = GetInt(buff);
  1456. hh1 = GetInt(buff, ':');
  1457. mm1 = GetInt(buff, ':');
  1458. ss1 = GetInt(buff, '.');
  1459. ms1_div10 = GetInt(buff);
  1460. hh2 = GetInt(buff, ':');
  1461. mm2 = GetInt(buff, ':');
  1462. ss2 = GetInt(buff, '.');
  1463. ms2_div10 = GetInt(buff);
  1464. Style = WToT(GetStr(buff));
  1465. Actor = WToT(GetStr(buff));
  1466. marginRect.left = GetInt(buff);
  1467. marginRect.right = GetInt(buff);
  1468. marginRect.top = marginRect.bottom = GetInt(buff);
  1469. Effect = WToT(GetStr(buff));
  1471. int len = min(Effect.GetLength(), buff.GetLength());
  1472. if(Effect.Left(len) == WToT(buff.Left(len))) Effect.Empty();
  1474. Style.TrimLeft('*');
  1475. if(!Style.CompareNoCase(_T("Default"))) Style = _T("Default");
  1477. ret.Add(buff,
  1478. file->IsUnicode(),
  1479. (((hh1*60 + mm1)*60) + ss1)*1000 + ms1_div10*10, 
  1480. (((hh2*60 + mm2)*60) + ss2)*1000 + ms2_div10*10, 
  1481. Style, Actor, Effect,
  1482. marginRect,
  1483. layer);
  1484. }
  1485. catch(...)
  1486. {
  1487. return(false);
  1488. }
  1489. }
  1490. else if(entry == L"fontname")
  1491. {
  1492. LoadUUEFont(file);
  1493. }
  1494. }
  1496. return(fRet);
  1497. }
  1499. static bool OpenXombieSub(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  1500. {
  1501. float version = 0;
  1503. // CMapStringToPtr stylemap;
  1505. CStringW buff;
  1506. while(file->ReadString(buff))
  1507. {
  1508. buff.Trim();
  1509. if(buff.IsEmpty() || buff.GetAt(0) == ';') continue;
  1511. CStringW entry;
  1513. // try {
  1514. entry = GetStr(buff, '=');
  1515. // }
  1516. // catch(...) {continue;}
  1518. entry.MakeLower();
  1520. if(entry == L"version")
  1521. {
  1522.             version = (float)GetFloat(buff);
  1523. }
  1524. else if(entry == L"screenhorizontal")
  1525. {
  1526. try {ret.m_dstScreenSize.cx = GetInt(buff);}
  1527. catch(...) {ret.m_dstScreenSize = CSize(0, 0); return(false);}
  1529. if(ret.m_dstScreenSize.cy <= 0)
  1530. {
  1531. ret.m_dstScreenSize.cy = (ret.m_dstScreenSize.cx == 1280)
  1532. ? 1024 
  1533. : ret.m_dstScreenSize.cx * 3 / 4;
  1534. }
  1535. }
  1536. else if(entry == L"screenvertical")
  1537. {
  1538. try {ret.m_dstScreenSize.cy = GetInt(buff);}
  1539. catch(...) {ret.m_dstScreenSize = CSize(0, 0); return(false);}
  1541. if(ret.m_dstScreenSize.cx <= 0)
  1542. {
  1543. ret.m_dstScreenSize.cx = (ret.m_dstScreenSize.cy == 1024)
  1544. ? 1280 
  1545. : ret.m_dstScreenSize.cy * 4 / 3;
  1546. }
  1547. }
  1548. else if(entry == L"style")
  1549. {
  1550. STSStyle* style = new STSStyle;
  1551. if(!style) return(false);
  1553. try 
  1554. {
  1555. CString StyleName;
  1557. StyleName = WToT(GetStr(buff)) + _T("_") + WToT(GetStr(buff));
  1558. style->fontName = WToT(GetStr(buff));
  1559. style->fontSize = GetFloat(buff);
  1560. for(int i = 0; i < 4; i++) style->colors[i] = (COLORREF)GetInt(buff);
  1561. for(int i = 0; i < 4; i++) style->alpha[i] = GetInt(buff);
  1562. style->fontWeight = !!GetInt(buff) ? FW_BOLD : FW_NORMAL;
  1563. style->fItalic = !!GetInt(buff);
  1564. style->fUnderline = !!GetInt(buff);
  1565. style->fStrikeOut = !!GetInt(buff);
  1566. style->fBlur = !!GetInt(buff);
  1567. style->fontScaleX = GetFloat(buff);
  1568. style->fontScaleY = GetFloat(buff);
  1569. style->fontSpacing = GetFloat(buff);
  1570. style->fontAngleX = GetFloat(buff);
  1571. style->fontAngleY = GetFloat(buff);
  1572. style->fontAngleZ = GetFloat(buff);
  1573. style->borderStyle = GetInt(buff);
  1574. style->outlineWidth = GetFloat(buff);
  1575. style->shadowDepth = GetFloat(buff);
  1576. style->scrAlignment = GetInt(buff);
  1577. style->marginRect.left = GetInt(buff);
  1578. style->marginRect.right = GetInt(buff);
  1579. style->marginRect.top = style->marginRect.bottom = GetInt(buff);
  1580. style->charSet = GetInt(buff);
  1582. style->fontScaleX = max(style->fontScaleX, 0);
  1583. style->fontScaleY = max(style->fontScaleY, 0);
  1584. style->fontSpacing = max(style->fontSpacing, 0);
  1585. style->borderStyle = style->borderStyle == 1 ? 0 : style->borderStyle == 3 ? 1 : 0;
  1586. style->outlineWidth = max(style->outlineWidth, 0);
  1587. style->shadowDepth = max(style->shadowDepth, 0);
  1589. ret.AddStyle(StyleName, style);
  1590. }
  1591. catch(...)
  1592. {
  1593. delete style;
  1594. return(false);
  1595. }
  1596. }
  1597. else if(entry == L"line")
  1598. {
  1599. try
  1600. {
  1601. CString id;
  1602. int hh1, mm1, ss1, ms1, hh2, mm2, ss2, ms2, layer = 0;
  1603. CString Style, Actor;
  1604. CRect marginRect;
  1606. if(GetStr(buff) != L"D") continue;
  1607. id = GetStr(buff);
  1608. layer = GetInt(buff);
  1609. hh1 = GetInt(buff, ':');
  1610. mm1 = GetInt(buff, ':');
  1611. ss1 = GetInt(buff, '.');
  1612. ms1 = GetInt(buff);
  1613. hh2 = GetInt(buff, ':');
  1614. mm2 = GetInt(buff, ':');
  1615. ss2 = GetInt(buff, '.');
  1616. ms2 = GetInt(buff);
  1617. Style = WToT(GetStr(buff)) + _T("_") + WToT(GetStr(buff));
  1618. Actor = WToT(GetStr(buff));
  1619. marginRect.left = GetInt(buff);
  1620. marginRect.right = GetInt(buff);
  1621. marginRect.top = marginRect.bottom = GetInt(buff);
  1623. Style.TrimLeft('*');
  1624. if(!Style.CompareNoCase(_T("Default"))) Style = _T("Default");
  1626. ret.Add(buff,
  1627. file->IsUnicode(),
  1628. (((hh1*60 + mm1)*60) + ss1)*1000 + ms1, 
  1629. (((hh2*60 + mm2)*60) + ss2)*1000 + ms2, 
  1630. Style, Actor, _T(""),
  1631. marginRect,
  1632. layer);
  1633. }
  1634. catch(...)
  1635. {
  1636. return(false);
  1637. }
  1638. }
  1639. else if(entry == L"fontname")
  1640. {
  1641. LoadUUEFont(file);
  1642. }
  1643. }
  1645. return(ret.GetCount() > 0);
  1646. }
  1648. #include "USFSubtitles.h"
  1650. static bool OpenUSF(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  1651. {
  1652. CString str;
  1653. while(file->ReadString(str))
  1654. {
  1655. if(str.Find(_T("USFSubtitles")) >= 0)
  1656. {
  1657. CUSFSubtitles usf;
  1658. if(usf.Read(file->GetFilePath()) && usf.ConvertToSTS(ret))
  1659. return(true);
  1661. break;
  1662. }
  1663. }
  1665. return(false);
  1666. }
  1668. static CStringW MPL22SSA(CStringW str)
  1669. {
  1670. CList<CStringW> sl;
  1671. Explode(str, sl, '|');
  1672. POSITION pos = sl.GetHeadPosition();
  1673. while(pos)
  1674. {
  1675. CStringW& s = sl.GetNext(pos);
  1676. if(s[0] == '/') {s = L"{\i1}" + s.Mid(1) + L"{\i0}";}
  1677. }
  1678. str = Implode(sl, 'n');
  1679. str.Replace(L"n", L"\N");
  1680. return str;
  1681. }
  1683. static bool OpenMPL2(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet)
  1684. {
  1685. CStringW buff;;
  1686. while(file->ReadString(buff))
  1687. {
  1688. buff.Trim();
  1689. if(buff.IsEmpty()) continue;
  1691. int start, end;
  1692. int c = swscanf(buff, L"[%d][%d]", &start, &end);
  1694. if(c == 2)
  1695. {
  1696. ret.Add(
  1697. MPL22SSA(buff.Mid(buff.Find(']', buff.Find(']')+1)+1)), 
  1698. file->IsUnicode(),
  1699. start*100, end*100);
  1700. }
  1701. else if(c != EOF) // might be another format
  1702. {
  1703. return(false);
  1704. }
  1705. }
  1707. return(ret.GetCount() > 0);
  1708. }
  1710. typedef bool (*STSOpenFunct)(CTextFile* file, CSimpleTextSubtitle& ret, int CharSet);
  1712. typedef struct {STSOpenFunct open; tmode mode;} OpenFunctStruct;
  1714. static OpenFunctStruct OpenFuncts[] = 
  1715. {
  1716. OpenSubRipper, TIME,
  1717. OpenOldSubRipper, TIME,
  1718. OpenSubViewer, TIME,
  1719. OpenMicroDVD, FRAME,
  1720. OpenSami, TIME,
  1721. OpenVPlayer, TIME,
  1722. OpenSubStationAlpha, TIME,
  1723. OpenXombieSub, TIME,
  1724. OpenUSF, TIME,
  1725. OpenMPL2, TIME,
  1726. };
  1728. static int nOpenFuncts = countof(OpenFuncts);
  1730. //
  1732. CSimpleTextSubtitle::CSimpleTextSubtitle()
  1733. {
  1734. m_mode = TIME;
  1735. m_dstScreenSize = CSize(0, 0);
  1736. m_defaultWrapStyle = 0;
  1737. m_collisions = 0;
  1738. m_fScaledBAS = false;
  1739. m_encoding = CTextFile::ASCII;
  1740. }
  1742. CSimpleTextSubtitle::~CSimpleTextSubtitle()
  1743. {
  1744. Empty();
  1745. }
  1746. /*
  1747. CSimpleTextSubtitle::CSimpleTextSubtitle(CSimpleTextSubtitle& sts)
  1748. {
  1749. *this = sts;
  1750. }
  1752. CSimpleTextSubtitle& CSimpleTextSubtitle::operator = (CSimpleTextSubtitle& sts)
  1753. {
  1754. Empty();
  1756. m_name = sts.m_name;
  1757. m_mode = sts.m_mode;
  1758. m_dstScreenSize = sts.m_dstScreenSize;
  1759. m_defaultWrapStyle = sts.m_defaultWrapStyle;
  1760. m_collisions = sts.m_collisions;
  1761. m_fScaledBAS = sts.m_fScaledBAS;
  1762. m_fSSA = sts.m_fSSA;
  1763. m_fUsingAutoGeneratedDefaultStyle = sts.m_fUsingAutoGeneratedDefaultStyle;
  1764. CopyStyles(sts.m_styles);
  1765. m_segments.Copy(sts.m_segments);
  1766. Copy(sts);
  1768. return(*this);
  1769. }
  1770. */
  1772. void CSimpleTextSubtitle::Copy(CSimpleTextSubtitle& sts)
  1773. {
  1774. Empty();
  1776. m_name = sts.m_name;
  1777. m_mode = sts.m_mode;
  1778. m_dstScreenSize = sts.m_dstScreenSize;
  1779. m_defaultWrapStyle = sts.m_defaultWrapStyle;
  1780. m_collisions = sts.m_collisions;
  1781. m_fScaledBAS = sts.m_fScaledBAS;
  1782. m_encoding = sts.m_encoding;
  1783. m_fUsingAutoGeneratedDefaultStyle = sts.m_fUsingAutoGeneratedDefaultStyle;
  1784. CopyStyles(sts.m_styles);
  1785. m_segments.Copy(sts.m_segments);
  1786. CSTSArray::Copy(sts);
  1787. }
  1789. void CSimpleTextSubtitle::Append(CSimpleTextSubtitle& sts, int timeoff)
  1790. {
  1791. if(timeoff < 0) 
  1792. {
  1793. timeoff = GetSize() > 0 ? GetAt(GetSize()-1).end : 0;
  1794. }
  1796. for(int i = 0, j = GetSize(); i < j; i++)
  1797. {
  1798. if(GetAt(i).start > timeoff) 
  1799. {
  1800. RemoveAt(i, j - i);
  1801. break;
  1802. }
  1803. }
  1805. CopyStyles(sts.m_styles, true);
  1807. for(int i = 0, j = sts.GetSize(); i < j; i++)
  1808. {
  1809. STSEntry stse = sts.GetAt(i);
  1810. stse.start += timeoff;
  1811. stse.end += timeoff;
  1812. stse.readorder += GetSize();
  1813. CSTSArray::Add(stse);
  1814. }
  1816. CreateSegments();
  1817. }
  1819. void CSTSStyleMap::Free()
  1820. {
  1821. POSITION pos = GetStartPosition();
  1822. while(pos) 
  1823. {
  1824. CString key;
  1825. void* ptr;
  1826. GetNextAssoc(pos, key, ptr);
  1827. delete (STSStyle*)ptr;
  1828. }
  1830. RemoveAll();
  1831. }
  1833. bool CSimpleTextSubtitle::CopyStyles(const CSTSStyleMap& styles, bool fAppend)
  1834. {
  1835. if(!fAppend) m_styles.Free();
  1837. POSITION pos = styles.GetStartPosition();
  1838. while(pos) 
  1839. {
  1840. CString key;
  1841. void* ptr;
  1842. styles.GetNextAssoc(pos, key, ptr);
  1844. STSStyle* s = new STSStyle;
  1845. if(!s) return(false);
  1847. *s = *((STSStyle*)ptr);
  1849. AddStyle(key, s);
  1850. }
  1852. return(true);
  1853. }
  1855. void CSimpleTextSubtitle::Empty()
  1856. {
  1857. m_dstScreenSize = CSize(0, 0);
  1858. m_styles.Free();
  1859. m_segments.RemoveAll();
  1860. RemoveAll();
  1861. }
  1863. void CSimpleTextSubtitle::Add(CStringW str, bool fUnicode, int start, int end, CString style, CString actor, CString effect, CRect marginRect, int layer, int readorder)
  1864. {
  1865. if(str.Trim().IsEmpty() || start > end) return;
  1867. str.Remove('r');
  1868. str.Replace(L"n", L"\N");
  1869. if(style.IsEmpty()) style = _T("Default");
  1870. style.TrimLeft('*');
  1872. STSEntry sub;
  1873. sub.str = str;
  1874. sub.fUnicode = fUnicode;
  1875. sub.style = style;
  1876. sub.actor = actor;
  1877. sub.effect = effect;
  1878. sub.marginRect = marginRect;
  1879. sub.layer = layer;
  1880. sub.start = start;
  1881. sub.end = end;
  1882. sub.readorder = readorder < 0 ? GetSize() : readorder;
  1883. int n = CSTSArray::Add(sub);
  1885. int len = m_segments.GetSize();
  1887.     if(len == 0)
  1888. {
  1889. STSSegment stss(start, end);
  1890. stss.subs.Add(n);
  1891. m_segments.Add(stss);
  1892. }
  1893. else if(end <= m_segments[0].start)
  1894. {
  1895. STSSegment stss(start, end);
  1896. stss.subs.Add(n);
  1897. m_segments.InsertAt(0, stss);
  1898. }
  1899. else if(start >= m_segments[len-1].end)
  1900. {
  1901. STSSegment stss(start, end);
  1902. stss.subs.Add(n);
  1903. m_segments.Add(stss);
  1904. }
  1905. else
  1906. {
  1907. if(start < m_segments[0].start)
  1908. {
  1909. STSSegment stss(start, m_segments[0].start);
  1910. stss.subs.Add(n);
  1911. start = m_segments[0].start;
  1912. m_segments.InsertAt(0, stss);
  1913. }
  1915. for(int i = 0; i < m_segments.GetCount(); i++)
  1916. {
  1917. STSSegment& s = m_segments[i];
  1919. if(start >= s.end)
  1920. continue;
  1922. if(end <= s.start)
  1923. break;
  1925. if(s.start < start && start < s.end)
  1926. {
  1927. STSSegment stss(s.start, start);
  1928. stss.subs.Copy(s.subs);
  1929. s.start = start;
  1930. m_segments.InsertAt(i, stss);
  1931. continue;
  1932. }
  1934. if(start <= s.start && s.end <= end)
  1935. {
  1936. for(int j = 0, k = s.subs.GetCount(); j <= k; j++)
  1937. {
  1938. if(j == k || sub.readorder < GetAt(s.subs[j]).readorder)
  1939. s.subs.InsertAt(j, n);
  1940. }
  1941. // s.subs.Add(n);
  1942. }
  1944. if(s.start < end && end < s.end)
  1945. {
  1946. STSSegment stss(s.start, end);
  1947. stss.subs.Copy(s.subs);
  1948. for(int j = 0, k = s.subs.GetCount(); j <= k; j++)
  1949. {
  1950. if(j == k || sub.readorder < GetAt(stss.subs[j]).readorder)
  1951. stss.subs.InsertAt(j, n);
  1952. }
  1953. // stss.subs.Add(n);
  1954. s.start = end;
  1955. m_segments.InsertAt(i, stss);
  1956. }
  1957. }
  1959. if(end > m_segments[m_segments.GetCount()-1].end)
  1960. {
  1961. STSSegment stss(m_segments[m_segments.GetCount()-1].end, end);
  1962. stss.subs.Add(n);
  1963. m_segments.Add(stss);
  1964. }
  1965. }
  1967. /*
  1968. str.Remove('r');
  1969. str.Replace(L"n", L"\N");
  1970. if(style.IsEmpty()) style = _T("Default");
  1972. int j = m_segments.GetSize();
  1973. for(int i = j-1; i >= 0; i--)
  1974. {
  1975. if(m_segments[i].end <= start)
  1976. {
  1977. break;
  1978. }
  1979. else if(m_segments[i].start >= start)
  1980. {
  1981. m_segments.SetSize(m_segments.GetSize()-1);
  1982. j--;
  1983. }
  1984. else if(m_segments[i].end > start)
  1985. {
  1986. if(i < j-1) m_segments.RemoveAt(i+1, j-i-1);
  1987. m_segments[i].end = start;
  1988. break;
  1989. }
  1990. }
  1992. if(m_segments.GetSize() == 0 && j > 0) 
  1993. CSTSArray::RemoveAll();
  1995. STSSegment stss(start, end);
  1996. int len = GetSize();
  1997. stss.subs.Add(len);
  1998. m_segments.Add(stss);
  2000. STSEntry sub;
  2001. sub.str = str;
  2002. sub.fUnicode = fUnicode;
  2003. sub.style = style;
  2004. sub.actor = actor;
  2005. sub.effect = effect;
  2006. sub.marginRect = marginRect;
  2007. sub.layer = layer;
  2008. sub.start = start;
  2009. sub.end = end;
  2010. sub.readorder = GetSize();
  2011. CSTSArray::Add(sub);
  2012. */
  2013. }
  2015. void CSimpleTextSubtitle::CreateDefaultStyle(int CharSet)
  2016. {
  2017. CString def(_T("Default"));
  2018. void* value;
  2020. // if(m_styles.IsEmpty())
  2021. if(!m_styles.Lookup(def, value))
  2022. {
  2023. STSStyle* style = new STSStyle;
  2024. if(!style) return;
  2026. style->charSet = CharSet;
  2028. AddStyle(def, style);
  2029. /*
  2030. for(int i = 0; i < GetSize(); i++)
  2031. {
  2032. (*this)[i].style = def;
  2033. }
  2034. */
  2035. m_fUsingAutoGeneratedDefaultStyle = true;
  2036. }
  2037. else
  2038. {
  2039. m_fUsingAutoGeneratedDefaultStyle = false;
  2040. }
  2041. }
  2043. void CSimpleTextSubtitle::ChangeUnknownStylesToDefault()
  2044. {
  2045. CMapStringToPtr unknown;
  2046. bool fReport = true;
  2048. for(int i = 0; i < GetSize(); i++)
  2049. {
  2050. STSEntry& stse = GetAt(i);
  2052. void* val;
  2053. if(!m_styles.Lookup(stse.style, val))
  2054. {
  2055. if(!unknown.Lookup(stse.style, val))
  2056. {
  2057. if(fReport)
  2058. {
  2059. CString msg;
  2060. msg.Format(_T("Unknown style found: "%s", changed to "Default"!nnPress Cancel to ignore further warnings."), stse.style);
  2061. if(MessageBox(NULL, msg, _T("Warning"), MB_OKCANCEL|MB_ICONWARNING) != IDOK) fReport = false;
  2062. }
  2064. unknown[stse.style] = NULL;
  2065. }
  2067. stse.style = _T("Default");
  2068. }
  2069. }
  2070. }
  2072. void CSimpleTextSubtitle::AddStyle(CString name, STSStyle* style)
  2073. {
  2074. int i, j;
  2076. if(name.IsEmpty()) name = _T("Default");
  2078. void* value;
  2079. if(m_styles.Lookup(name, value)) 
  2080. {
  2081. if(*((STSStyle*)value) == *style)
  2082. {
  2083. delete style;
  2084. return;
  2085. }
  2087. int len = name.GetLength();
  2089. for(i = len; i > 0 && _istdigit(name[i-1]); i--);
  2091. int idx = 1;
  2093. CString name2 = name;
  2095. if(i < len && _stscanf(name.Right(len-i), _T("%d"), &idx) == 1)
  2096. {
  2097. name2 = name.Left(i);
  2098. }
  2100. idx++;
  2102. CString name3;
  2103. do
  2104. {
  2105. name3.Format(_T("%s%d"), name2, idx);
  2106. idx++;
  2107. }
  2108. while(m_styles[name3]);
  2110. m_styles.RemoveKey(name);
  2111. m_styles[name3] = (STSStyle*)value;
  2113. for(i = 0, j = GetSize(); i < j; i++)
  2114. {
  2115. STSEntry& stse = GetAt(i);
  2116. if(stse.style == name) stse.style = name3;
  2117. }
  2118. }
  2120. m_styles[name] = style;
  2121. }
  2123. bool CSimpleTextSubtitle::SetDefaultStyle(STSStyle& s)
  2124. {
  2125. void* val;
  2126. if(m_styles.Lookup(_T("Default"), val))
  2127. {
  2128. *((STSStyle*)val) = s;
  2129. m_fUsingAutoGeneratedDefaultStyle = false;
  2130. return(true);
  2131. }
  2133. return(false);
  2134. }
  2136. bool CSimpleTextSubtitle::GetDefaultStyle(STSStyle& s)
  2137. {
  2138. void* val;
  2139. if(m_styles.Lookup(_T("Default"), val))
  2140. {
  2141. s = *((STSStyle*)val);
  2142. return(true);
  2143. }
  2145. return(false);
  2146. }
  2148. void CSimpleTextSubtitle::ConvertToTimeBased(double fps)
  2149. {
  2150. if(m_mode == TIME) return;
  2152. for(int i = 0, j = GetSize(); i < j; i++)
  2153. {
  2154. STSEntry& stse = (*this)[i];
  2155. stse.start = int(1.0 * stse.start * 1000 / fps + 0.5);
  2156. stse.end = int(1.0 * stse.end * 1000 / fps + 0.5);
  2157. }
  2159. m_mode = TIME;
  2161. CreateSegments();
  2162. }
  2164. void CSimpleTextSubtitle::ConvertToFrameBased(double fps)
  2165. {
  2166. if(m_mode == FRAME) return;
  2168. for(int i = 0, j = GetSize(); i < j; i++)
  2169. {
  2170. STSEntry& stse = (*this)[i];
  2171. stse.start = int(1.0 * stse.start * fps / 1000 + 0.5);
  2172. stse.end = int(1.0 * stse.end * fps / 1000 + 0.5);
  2173. }
  2175. m_mode = FRAME;
  2177. CreateSegments();
  2178. }
  2180. int CSimpleTextSubtitle::SearchSub(int t, double fps)
  2181. {
  2182. int i = 0, j = GetSize() - 1, ret = -1;
  2184. if(j >= 0 && t >= TranslateStart(j, fps))
  2185. {
  2186. return(j);
  2187. }
  2189. while(i < j)
  2190. {
  2191. int mid = (i + j) >> 1;
  2193. int midt = TranslateStart(mid, fps);
  2195. if(t == midt)
  2196. {
  2197. while(mid > 0 && t == TranslateStart(mid-1, fps)) mid--;
  2198. ret = mid;
  2199. break;
  2200. }
  2201. else if(t < midt)
  2202. {
  2203. ret = -1;
  2204. if(j == mid) mid--;
  2205. j = mid;
  2206. }
  2207. else if(t > midt)
  2208. {
  2209. ret = mid;
  2210. if(i == mid) mid++;
  2211. i = mid;
  2212. }
  2213. }
  2215. return(ret);
  2216. }
  2218. const STSSegment* CSimpleTextSubtitle::SearchSubs(int t, double fps, /*[out]*/ int* iSegment, int* nSegments)
  2219. {
  2220. int i = 0, j = m_segments.GetSize() - 1, ret = -1;
  2222. if(nSegments) *nSegments = j+1;
  2224. if(j >= 0 && t >= TranslateSegmentStart(j, fps) && t < TranslateSegmentEnd(j, fps))
  2225. {
  2226. if(iSegment) *iSegment = j;
  2227. return(&m_segments[j]);
  2228. }
  2230. if(j >= 0 && t >= TranslateSegmentEnd(j, fps))
  2231. {
  2232. if(iSegment) *iSegment = j+1;
  2233. return(NULL);
  2234. }
  2236. if(j > 0 && t < TranslateSegmentStart(i, fps))
  2237. {
  2238. if(iSegment) *iSegment = -1;
  2239. return(NULL);
  2240. }
  2242. while(i < j)
  2243. {
  2244. int mid = (i + j) >> 1;
  2246. int midt = TranslateSegmentStart(mid, fps);
  2248. if(t == midt)
  2249. {
  2250. ret = mid;
  2251. break;
  2252. }
  2253. else if(t < midt)
  2254. {
  2255. ret = -1;
  2256. if(j == mid) mid--;
  2257. j = mid;
  2258. }
  2259. else if(t > midt)
  2260. {
  2261. ret = mid;
  2262. if(i == mid) mid++;
  2263. i = mid;
  2264. }
  2265. }
  2267. if(0 <= ret && ret < m_segments.GetSize())
  2268. {
  2269. if(iSegment) *iSegment = ret;
  2270. }
  2272. if(0 <= ret && ret < m_segments.GetSize() 
  2273. && m_segments[ret].subs.GetSize() > 0
  2274. && TranslateSegmentStart(ret, fps) <= t && t < TranslateSegmentEnd(ret, fps))
  2275. {
  2276. return(&m_segments[ret]);
  2277. }
  2279. return(NULL);
  2280. }
  2282. int CSimpleTextSubtitle::TranslateStart(int i, double fps)
  2283. {
  2284. return(i < 0 || GetSize() <= i ? -1 :
  2285. m_mode == TIME ? GetAt(i).start :
  2286. m_mode == FRAME ? (int)(GetAt(i).start*1000/fps) :
  2287. 0);
  2288. }
  2290. int CSimpleTextSubtitle::TranslateEnd(int i, double fps)
  2291. {
  2292. return(i < 0 || GetSize() <= i ? -1 :
  2293. m_mode == TIME ? GetAt(i).end :
  2294. m_mode == FRAME ? (int)(GetAt(i).end*1000/fps) :
  2295. 0);
  2296. }
  2298. int CSimpleTextSubtitle::TranslateSegmentStart(int i, double fps)
  2299. {
  2300. return(i < 0 || m_segments.GetSize() <= i ? -1 :
  2301. m_mode == TIME ? m_segments[i].start :
  2302. m_mode == FRAME ? (int)(m_segments[i].start*1000/fps) :
  2303. 0);
  2304. }
  2306. int CSimpleTextSubtitle::TranslateSegmentEnd(int i, double fps)
  2307. {
  2308. return(i < 0 || m_segments.GetSize() <= i ? -1 :
  2309. m_mode == TIME ? m_segments[i].end :
  2310. m_mode == FRAME ? (int)(m_segments[i].end*1000/fps) :
  2311. 0);
  2312. }
  2314. STSStyle* CSimpleTextSubtitle::GetStyle(int i)
  2315. {
  2316. STSStyle* style = (STSStyle*)m_styles[GetAt(i).style];
  2317. if(!style) style = (STSStyle*)m_styles[_T("Default")];
  2318. ASSERT(style);
  2319. return(style);
  2320. }
  2322. bool CSimpleTextSubtitle::GetStyle(int i, STSStyle& stss)
  2323. {
  2324. CString def = _T("Default");
  2326. STSStyle* style = (STSStyle*)m_styles[GetAt(i).style];
  2327. STSStyle* defstyle = (STSStyle*)m_styles[def];
  2328. if(!style) {if(defstyle) {ASSERT(0); CreateDefaultStyle(DEFAULT_CHARSET); defstyle = (STSStyle*)m_styles[def];} style = defstyle;}
  2329. if(!style) {ASSERT(0); return(false);}
  2330. stss = *style;
  2331. if(stss.relativeTo == 2 && defstyle)
  2332. stss.relativeTo = defstyle->relativeTo;
  2333. return(true);
  2334. }
  2336. int CSimpleTextSubtitle::GetCharSet(int i)
  2337. {
  2338. STSStyle stss;
  2339. GetStyle(i, stss);
  2340. return(stss.charSet);
  2341. }
  2343. bool CSimpleTextSubtitle::IsEntryUnicode(int i)
  2344. {
  2345. return(GetAt(i).fUnicode);
  2346. }
  2348. void CSimpleTextSubtitle::ConvertUnicode(int i, bool fUnicode)
  2349. {
  2350. STSEntry& stse = GetAt(i);
  2352. if(stse.fUnicode ^ fUnicode)
  2353. {
  2354. int CharSet = GetCharSet(i);
  2356. stse.str = fUnicode 
  2357. ? MBCSSSAToUnicode(stse.str, CharSet)
  2358. : UnicodeSSAToMBCS(stse.str, CharSet);
  2360. stse.fUnicode = fUnicode;
  2361. }
  2362. }
  2364. CStringA CSimpleTextSubtitle::GetStrA(int i, bool fSSA)
  2365. {
  2366. return(WToA(GetStrWA(i, fSSA)));
  2367. }
  2369. CStringW CSimpleTextSubtitle::GetStrW(int i, bool fSSA)
  2370. {
  2371. bool fUnicode = IsEntryUnicode(i);
  2372. int CharSet = GetCharSet(i);
  2374. CStringW str = GetAt(i).str;
  2376. if(!fUnicode)
  2377. str = MBCSSSAToUnicode(str, CharSet);
  2379. if(!fSSA)
  2380. str = RemoveSSATags(str, fUnicode, CharSet);
  2382. return(str);
  2383. }
  2385. CStringW CSimpleTextSubtitle::GetStrWA(int i, bool fSSA)
  2386. {
  2387. bool fUnicode = IsEntryUnicode(i);
  2388. int CharSet = GetCharSet(i);
  2390. CStringW str = GetAt(i).str;
  2392. if(fUnicode)
  2393. str = UnicodeSSAToMBCS(str, CharSet);
  2395. if(!fSSA)
  2396. str = RemoveSSATags(str, fUnicode, CharSet);
  2398. return(str);
  2399. }
  2401. void CSimpleTextSubtitle::SetStr(int i, CStringA str, bool fUnicode)
  2402. {
  2403. SetStr(i, AToW(str), false);
  2404. }
  2406. void CSimpleTextSubtitle::SetStr(int i, CStringW str, bool fUnicode)
  2407. {
  2408. STSEntry& stse = GetAt(i);
  2410. str.Replace(L"n", L"\N"); 
  2412. if(stse.fUnicode && !fUnicode) stse.str = MBCSSSAToUnicode(str, GetCharSet(i));
  2413. else if(!stse.fUnicode && fUnicode) stse.str = UnicodeSSAToMBCS(str, GetCharSet(i));
  2414. else stse.str = str;
  2415. }
  2417. static int comp1(const void* a, const void* b)
  2418. {
  2419. int ret = ((STSEntry*)a)->start - ((STSEntry*)b)->start;
  2420. if(ret == 0) ret = ((STSEntry*)a)->layer - ((STSEntry*)b)->layer;
  2421. if(ret == 0) ret = ((STSEntry*)a)->readorder - ((STSEntry*)b)->readorder;
  2422. return(ret);
  2423. }
  2425. static int comp2(const void* a, const void* b)
  2426. {
  2427. return(((STSEntry*)a)->readorder - ((STSEntry*)b)->readorder);
  2428. }
  2430. void CSimpleTextSubtitle::Sort(bool fRestoreReadorder)
  2431. {
  2432. qsort(GetData(), GetSize(), sizeof(STSEntry), !fRestoreReadorder ? comp1 : comp2);
  2433. CreateSegments();
  2434. }
  2436. static int intcomp(const void* i1, const void* i2)
  2437. {
  2438. return(*((int*)i1) - *((int*)i2));
  2439. }
  2441. void CSimpleTextSubtitle::CreateSegments()
  2442. {
  2443. m_segments.RemoveAll();
  2445. int i, j;
  2447. CArray<int> breakpoints;
  2449. for(i = 0; i < GetSize(); i++)
  2450. {
  2451. STSEntry& stse = GetAt(i);
  2452. breakpoints.Add(stse.start);
  2453. breakpoints.Add(stse.end);
  2454. }
  2456. qsort(breakpoints.GetData(), breakpoints.GetSize(), sizeof(int), intcomp);
  2458. int* ptr = breakpoints.GetData(), prev = ptr ? *ptr : NULL;
  2460. for(i = breakpoints.GetSize(); i > 0; i--, ptr++)
  2461. {
  2462. if(*ptr != prev) 
  2463. {
  2464. m_segments.Add(STSSegment(prev, *ptr));
  2465. prev = *ptr;
  2466. }
  2467. }
  2469. for(i = 0; i < GetSize(); i++)
  2470. {
  2471. STSEntry& stse = GetAt(i);
  2472. for(j = 0; j < m_segments.GetSize() && m_segments[j].start < stse.start; j++);
  2473. for(; j < m_segments.GetSize() && m_segments[j].end <= stse.end; j++) 
  2474. m_segments[j].subs.Add(i);
  2475. }
  2477. OnChanged();
  2478. /*
  2479. for(i = 0, j = m_segments.GetSize(); i < j; i++)
  2480. {
  2481. STSSegment& stss = m_segments[i];
  2483. TRACE(_T("%d - %d"), stss.start, stss.end);
  2485. for(int k = 0, l = stss.subs.GetSize(); k < l; k++)
  2486. {
  2487. TRACE(_T(", %d"), stss.subs[k]);
  2488. }
  2490. TRACE(_T("n"));
  2491. }
  2492. */
  2493. }
  2495. bool CSimpleTextSubtitle::Open(CString fn, int CharSet, CString name)
  2496. {
  2497. Empty();
  2499. CWebTextFile f;
  2500. if(!f.Open(fn)) return(false);
  2502. fn.Replace('\', '/');
  2503. if(name.IsEmpty())
  2504. {
  2505. name = fn.Left(fn.ReverseFind('.'));
  2506. name = name.Mid(name.ReverseFind('/')+1);
  2507. name = name.Mid(name.ReverseFind('.')+1);
  2508. }
  2510. return(Open(&f, CharSet, name));
  2511. }
  2513. static int CountLines(CTextFile* f, ULONGLONG from, ULONGLONG to)
  2514. {
  2515. int n = 0;
  2516. CString s;
  2517. f->Seek(from, 0);
  2518. while(f->ReadString(s) && f->GetPosition() < to) n++;
  2519. return(n);
  2520. }
  2522. bool CSimpleTextSubtitle::Open(CTextFile* f, int CharSet, CString name)
  2523. {
  2524. Empty();
  2526. ULONGLONG pos = f->GetPosition();
  2528. for(int i = 0; i < nOpenFuncts; i++)
  2529. {
  2530. if(!OpenFuncts[i].open(f, *this, CharSet) /*|| !GetSize()*/) 
  2531. {
  2532. if(GetSize() > 0)
  2533. {
  2534. int n = CountLines(f, pos, f->GetPosition());
  2535. CString s;
  2536. s.Format(_T("Syntax error at line %d!t"), n+1);
  2537. AfxMessageBox(s, MB_OK|MB_ICONERROR);
  2538. Empty();
  2539. break;
  2540. }
  2542. f->Seek(pos, 0);
  2543. Empty();
  2544. continue;
  2545. }
  2547. m_name = name;
  2548. m_mode = OpenFuncts[i].mode;
  2549. m_encoding = f->GetEncoding();
  2550. m_path = f->GetFilePath();
  2552. // Sort();
  2553. CreateSegments();
  2555. CWebTextFile f2;
  2556. if(f2.Open(f->GetFilePath() + _T(".style"))) 
  2557. OpenSubStationAlpha(&f2, *this, CharSet);
  2559. CreateDefaultStyle(CharSet);
  2561. ChangeUnknownStylesToDefault();
  2563. if(m_dstScreenSize == CSize(0, 0)) m_dstScreenSize = CSize(384, 288);
  2565. return(true);
  2566. }
  2568. return(false);
  2569. }
  2571. bool CSimpleTextSubtitle::Open(BYTE* data, int len, int CharSet, CString name)
  2572. {
  2573. TCHAR path[MAX_PATH];
  2574. if(!GetTempPath(MAX_PATH, path)) return(false);
  2576. TCHAR fn[MAX_PATH];
  2577. if(!GetTempFileName(path, _T("vs"), 0, fn)) return(false);
  2579. FILE* tmp = _tfopen(fn, _T("wb"));
  2580. if(!tmp) return(false);
  2582. int i = 0;
  2583. for(; i <= (len-1024); i += 1024) fwrite(&data[i], 1024, 1, tmp);
  2584. if(len > i) fwrite(&data[i], len - i, 1, tmp);
  2586. fclose(tmp);
  2588. bool fRet = Open(fn, CharSet, name);
  2590. _tremove(fn);
  2592. return(fRet);
  2593. }
  2595. bool CSimpleTextSubtitle::SaveAs(CString fn, exttype et, double fps, CTextFile::enc e)
  2596. {
  2597. if(fn.Mid(fn.ReverseFind('.')+1).CompareNoCase(exttypestr[et])) 
  2598. {
  2599. if(fn[fn.GetLength()-1] != '.') fn += _T("."); 
  2600. fn += exttypestr[et];
  2601. }
  2603. CTextFile f;
  2604. if(!f.Save(fn, e))
  2605. return(false);
  2607. if(et == EXTSMI)
  2608. {
  2609. CString str;
  2611. str += _T("<SAMI>n<HEAD>n");
  2612. str += _T("<STYLE TYPE="text/css">n");
  2613. str += _T("<!--n");
  2614. str += _T("P {margin-left: 16pt; margin-right: 16pt; margin-bottom: 16pt; margin-top: 16pt;n");
  2615. str += _T("   text-align: center; font-size: 18pt; font-family: arial; font-weight: bold; color: #f0f0f0;}n");
  2616. str += _T(".UNKNOWNCC {Name:Unknown; lang:en-US; SAMIType:CC;}n");
  2617. str += _T("-->n");
  2618. str += _T("</STYLE>n");
  2619. str += _T("</HEAD>n");
  2620. str += _T("n");
  2621. str += _T("<BODY>n");
  2623. f.WriteString(str);
  2624. }
  2625. else if(et == EXTSSA || et == EXTASS)
  2626. {
  2627. CString str;
  2629. str  = _T("[Script Info]n");
  2630. str += (et == EXTSSA) ? _T("; This is a Sub Station Alpha v4 script.n") : _T("; This is an Advanced Sub Station Alpha v4+ script.n");
  2631. str += _T("; For Sub Station Alpha info and downloads,n");
  2632. str += _T("; go to http://www.eswat.demon.co.uk/n");
  2633. str += _T("; or email kotus@eswat.demon.co.ukn");
  2634. str += _T("; n");
  2635. if(et == EXTASS) 
  2636. {
  2637. str += _T("; Advanced Sub Station Alpha script format developed by #Anime-Fansubs@EfNETn");
  2638. str += _T("; http://www.anime-fansubs.orgn");
  2639. str += _T("; n");
  2640. str += _T("; For additional info and downloads go to http://gabest.org/n");
  2641. str += _T("; or email gabest@freemail.hun");
  2642. str += _T("; n");
  2643. }
  2644. str += _T("; Note: This file was saved by Subresync.n");
  2645. str += _T("; n");
  2646. str += (et == EXTSSA) ? _T("ScriptType: v4.00n") : _T("ScriptType: v4.00+n");
  2647. str += (m_collisions == 0) ? _T("Collisions: Normaln") : _T("Collisions: Reversen");
  2648. if(et == EXTASS && m_fScaledBAS) str += _T("ScaledBorderAndShadow: Yesn");
  2649. str += _T("PlayResX: %dn");
  2650. str += _T("PlayResY: %dn");
  2651. str += _T("Timer: 100.0000n");
  2652. str += _T("n");
  2653. str += (et == EXTSSA) 
  2654. ? _T("[V4 Styles]nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, TertiaryColour, BackColour, Bold, Italic, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, AlphaLevel, Encodingn")
  2655. : _T("[V4+ Styles]nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encodingn");
  2657. CString str2;
  2658. str2.Format(str, m_dstScreenSize.cx, m_dstScreenSize.cy);
  2659. f.WriteString(str2);
  2661. str  = (et == EXTSSA)
  2662. ? _T("Style: %s,%s,%d,&H%06x,&H%06x,&H%06x,&H%06x,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%dn")
  2663. : _T("Style: %s,%s,%d,&H%08x,&H%08x,&H%08x,&H%08x,%d,%d,%d,%d,%d,%d,%d,%.2f,%d,%d,%d,%d,%d,%d,%d,%dn");
  2665. POSITION pos = m_styles.GetStartPosition();
  2666. while(pos) 
  2667. {
  2668. CString key;
  2669. void* ptr;
  2670. m_styles.GetNextAssoc(pos, key, ptr);
  2671. STSStyle* s = (STSStyle*)ptr;
  2673. if(et == EXTSSA)
  2674. {
  2675. CString str2;
  2676. str2.Format(str, key,
  2677. s->fontName, (int)s->fontSize,
  2678. s->colors[0]&0xffffff, 
  2679. s->colors[1]&0xffffff, 
  2680. s->colors[2]&0xffffff, 
  2681. s->colors[3]&0xffffff, 
  2682. s->fontWeight > FW_NORMAL ? -1 : 0, s->fItalic ? -1 : 0,
  2683. s->borderStyle == 0 ? 1 : s->borderStyle == 1 ? 3 : 0, 
  2684. (int)s->outlineWidth, (int)s->shadowDepth, 
  2685. s->scrAlignment <= 3 ? s->scrAlignment : s->scrAlignment <= 6 ? ((s->scrAlignment-3)|8) : s->scrAlignment <= 9 ? ((s->scrAlignment-6)|4) : 2,
  2686. s->marginRect.left, s->marginRect.right, (s->marginRect.top + s->marginRect.bottom) / 2,
  2687. s->alpha[0],
  2688. s->charSet);
  2689. f.WriteString(str2);
  2690. }
  2691. else
  2692. {
  2693. CString str2;
  2694. str2.Format(str, key,
  2695. s->fontName, (int)s->fontSize,
  2696. (s->colors[0]&0xffffff) | (s->alpha[0]<<24),
  2697. (s->colors[1]&0xffffff) | (s->alpha[1]<<24),
  2698. (s->colors[2]&0xffffff) | (s->alpha[2]<<24),
  2699. (s->colors[3]&0xffffff) | (s->alpha[3]<<24),
  2700. s->fontWeight > FW_NORMAL ? -1 : 0, 
  2701. s->fItalic ? -1 : 0, s->fUnderline ? -1 : 0, s->fStrikeOut ? -1 : 0, 
  2702. (int)s->fontScaleX, (int)s->fontScaleY,
  2703. (int)s->fontSpacing, (float)s->fontAngleZ,
  2704. s->borderStyle == 0 ? 1 : s->borderStyle == 1 ? 3 : 0, 
  2705. (int)s->outlineWidth, (int)s->shadowDepth, 
  2706. s->scrAlignment,
  2707. s->marginRect.left, s->marginRect.right, (s->marginRect.top + s->marginRect.bottom) / 2,
  2708. s->charSet);
  2709. f.WriteString(str2);
  2710. }
  2711. }
  2713. if(GetSize() > 0)
  2714. {
  2715. str  = _T("n");
  2716. str += _T("[Events]n");
  2717. str += (et == EXTSSA) 
  2718. ? _T("Format: Marked, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Textn")
  2719. : _T("Format: Layer, Start, End, Style, Actor, MarginL, MarginR, MarginV, Effect, Textn");
  2720. f.WriteString(str);
  2721. }
  2722. }
  2724. CStringW fmt = 
  2725. et == EXTSRT ? L"%dn%02d:%02d:%02d,%03d --> %02d:%02d:%02d,%03dn%snn" :
  2726. et == EXTSUB ? L"{%d}{%d}%sn" :
  2727. et == EXTSMI ? L"<SYNC Start=%d><P Class=UNKNOWNCC>n%sn<SYNC Start=%d><P Class=UNKNOWNCC>&nbsp;n" :
  2728. et == EXTPSB ? L"{%d:%02d:%02d}{%d:%02d:%02d}%sn" :
  2729. et == EXTSSA ? L"Dialogue: Marked=0,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s,%s,%04d,%04d,%04d,%s,%sn" :
  2730. et == EXTASS ? L"Dialogue: %d,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s,%s,%04d,%04d,%04d,%s,%sn" :
  2731.    L"";
  2732. // Sort(true);
  2734. for(int i = 0, j = GetSize(), k = 0; i < j; i++)
  2735. {
  2736. STSEntry& stse = GetAt(i);
  2738. int t1 = TranslateStart(i, fps);
  2739. if(t1 < 0) {k++; continue;}
  2741. int t2 = TranslateEnd(i, fps);
  2743. int hh1 = (t1/60/60/1000);
  2744. int mm1 = (t1/60/1000)%60;
  2745. int ss1 = (t1/1000)%60;
  2746. int ms1 = (t1)%1000;
  2747. int hh2 = (t2/60/60/1000);
  2748. int mm2 = (t2/60/1000)%60;
  2749. int ss2 = (t2/1000)%60;
  2750. int ms2 = (t2)%1000;
  2752. CStringW str = f.IsUnicode()
  2753. ? GetStrW(i, et == EXTSSA || et == EXTASS)
  2754. : GetStrWA(i, et == EXTSSA || et == EXTASS);
  2756. CStringW str2;
  2758. if(et == EXTSRT)
  2759. {
  2760. str2.Format(fmt, i-k+1, hh1, mm1, ss1, ms1, hh2, mm2, ss2, ms2, str);
  2761. }
  2762. else if(et == EXTSUB)
  2763. {
  2764. str.Replace('n', '|');
  2765. str2.Format(fmt, int(t1*fps/1000), int(t2*fps/1000), str);
  2766. }
  2767. else if(et == EXTSMI)
  2768. {
  2769. str.Replace(L"n", L"<br>");
  2770. str2.Format(fmt, t1, str, t2);
  2771. }
  2772. else if(et == EXTPSB)
  2773. {
  2774. str.Replace('n', '|');
  2775. str2.Format(fmt, hh1, mm1, ss1, hh2, mm2, ss2, str);
  2776. }
  2777. else if(et == EXTSSA)
  2778. {
  2779. str.Replace(L"n", L"\N");
  2780. str2.Format(fmt, 
  2781. hh1, mm1, ss1, ms1/10,
  2782. hh2, mm2, ss2, ms2/10,
  2783. TToW(stse.style), TToW(stse.actor), 
  2784. stse.marginRect.left, stse.marginRect.right, (stse.marginRect.top + stse.marginRect.bottom) / 2,
  2785. TToW(stse.effect), str);
  2786. }
  2787. else if(et == EXTASS)
  2788. {
  2789. str.Replace(L"n", L"\N");
  2790. str2.Format(fmt, 
  2791. stse.layer, 
  2792. hh1, mm1, ss1, ms1/10,
  2793. hh2, mm2, ss2, ms2/10,
  2794. TToW(stse.style), TToW(stse.actor), 
  2795. stse.marginRect.left, stse.marginRect.right, (stse.marginRect.top + stse.marginRect.bottom) / 2,
  2796. TToW(stse.effect), str);
  2797. }
  2799. f.WriteString(str2);
  2800. }
  2802. // Sort();
  2804. if(et == EXTSMI)
  2805. {
  2806. f.WriteString(_T("</BODY>n</SAMI>n"));
  2807. }
  2809. void* val;
  2810. if(!m_fUsingAutoGeneratedDefaultStyle && m_styles.Lookup(_T("Default"), val) && et != EXTSSA && et != EXTASS)
  2811. {
  2812. STSStyle* s = (STSStyle*)val;
  2814. CTextFile f;
  2815. if(!f.Save(fn + _T(".style"), e))
  2816. return(false);
  2818. CString str, str2;
  2820. str += _T("ScriptType: v4.00+n");
  2821. str += _T("PlayResX: %dn");
  2822. str += _T("PlayResY: %dn");
  2823. str += _T("n");
  2824. str += _T("[V4+ Styles]nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encodingn");
  2825. str2.Format(str, m_dstScreenSize.cx, m_dstScreenSize.cy);
  2826. f.WriteString(str2);
  2828. str  = _T("Style: Default,%s,%d,&H%08x,&H%08x,&H%08x,&H%08x,%d,%d,%d,%d,%d,%d,%d,%.2f,%d,%d,%d,%d,%d,%d,%d,%dn");
  2829. str2.Format(str,
  2830. s->fontName, (int)s->fontSize,
  2831. (s->colors[0]&0xffffff) | (s->alpha[0]<<24),
  2832. (s->colors[1]&0xffffff) | (s->alpha[1]<<24),
  2833. (s->colors[2]&0xffffff) | (s->alpha[2]<<24),
  2834. (s->colors[3]&0xffffff) | (s->alpha[3]<<24),
  2835. s->fontWeight > FW_NORMAL ? -1 : 0, 
  2836. s->fItalic ? -1 : 0, s->fUnderline ? -1 : 0, s->fStrikeOut ? -1 : 0, 
  2837. (int)s->fontScaleX, (int)s->fontScaleY,
  2838. (int)s->fontSpacing, (float)s->fontAngleZ,
  2839. s->borderStyle == 0 ? 1 : s->borderStyle == 1 ? 3 : 0, 
  2840. (int)s->outlineWidth, (int)s->shadowDepth, 
  2841. s->scrAlignment,
  2842. s->marginRect.left, s->marginRect.right, (s->marginRect.top + s->marginRect.bottom) / 2,
  2843. s->charSet);
  2844. f.WriteString(str2);
  2845. }
  2847. return(true);
  2848. }
  2850. ////////////////////////////////////////////////////////////////////
  2852. STSStyle::STSStyle()
  2853. {
  2854. SetDefault();
  2855. }
  2857. void STSStyle::SetDefault()
  2858. {
  2859. marginRect = CRect(20, 20, 20, 20);
  2860. scrAlignment = 2;
  2861. borderStyle = 0;
  2862. outlineWidth = 2;
  2863. shadowDepth = 3;
  2864. colors[0] = 0x00ffffff;
  2865. colors[1] = 0x0000ffff;
  2866. colors[2] = 0x00000000;
  2867. colors[3] = 0x00000000;
  2868. alpha[0] = 0x00;
  2869. alpha[1] = 0x00;
  2870. alpha[2] = 0x00;
  2871. alpha[3] = 0x80;
  2872.     charSet = DEFAULT_CHARSET;
  2873. fontName = _T("Arial");
  2874. fontSize = 18;
  2875. fontScaleX = fontScaleY = 100;
  2876. fontSpacing = 0;
  2877. fontWeight = FW_BOLD;
  2878. fItalic = false;
  2879. fUnderline = false;
  2880. fStrikeOut = false;
  2881. fBlur = false;
  2882. fontAngleZ = fontAngleX = fontAngleY = 0;
  2883. relativeTo = 2;
  2884. }
  2886. bool STSStyle::operator == (STSStyle& s)
  2887. {
  2888. return(marginRect == s.marginRect 
  2889. && scrAlignment == s.scrAlignment
  2890. && borderStyle == s.borderStyle
  2891. && outlineWidth == s.outlineWidth
  2892. && shadowDepth == s.shadowDepth 
  2893. && *((int*)&colors[0]) == *((int*)&s.colors[0])
  2894. && *((int*)&colors[1]) == *((int*)&s.colors[1])
  2895. && *((int*)&colors[2]) == *((int*)&s.colors[2])
  2896. && *((int*)&colors[3]) == *((int*)&s.colors[3])
  2897. && alpha[0] == s.alpha[0]
  2898. && alpha[1] == s.alpha[1]
  2899. && alpha[2] == s.alpha[2]
  2900. && alpha[3] == s.alpha[3]
  2901. && fBlur == s.fBlur
  2902. && relativeTo == s.relativeTo
  2903. && IsFontStyleEqual(s));
  2904. }
  2906. bool STSStyle::IsFontStyleEqual(STSStyle& s)
  2907. {
  2908. return(
  2909. charSet == s.charSet
  2910. && fontName == s.fontName
  2911. && fontSize == s.fontSize
  2912. && fontScaleX == s.fontScaleX
  2913. && fontScaleY == s.fontScaleY
  2914. && fontSpacing == s.fontSpacing
  2915. && fontWeight == s.fontWeight
  2916. && fItalic == s.fItalic
  2917. && fUnderline == s.fUnderline
  2918. && fStrikeOut == s.fStrikeOut
  2919. && fontAngleZ == s.fontAngleZ
  2920. && fontAngleX == s.fontAngleX
  2921. && fontAngleY == s.fontAngleY);
  2922. }
  2924. void STSStyle::operator = (LOGFONT& lf)
  2925. {
  2926. charSet = lf.lfCharSet;
  2927. fontName = lf.lfFaceName;
  2928. HDC hDC = GetDC(0);
  2929. fontSize = -MulDiv(lf.lfHeight, 72, GetDeviceCaps(hDC, LOGPIXELSY));
  2930. ReleaseDC(0, hDC);
  2931. // fontAngleZ = (float)(1.0*lf.lfEscapement/10);
  2932. fontWeight = lf.lfWeight;
  2933. fItalic = !!lf.lfItalic;
  2934. fUnderline = !!lf.lfUnderline;
  2935. fStrikeOut = !!lf.lfStrikeOut;
  2936. }
  2938. LOGFONTA& operator <<= (LOGFONTA& lfa, STSStyle& s)
  2939. {
  2940. lfa.lfCharSet = s.charSet;
  2941. #ifdef UNICODE
  2942. wcstombs(lfa.lfFaceName, s.fontName, 32);
  2943. #else
  2944. strncpy(lfa.lfFaceName, s.fontName, 32);
  2945. #endif
  2946. HDC hDC = GetDC(0);
  2947. lfa.lfHeight = -MulDiv((int)(s.fontSize+0.5), GetDeviceCaps(hDC, LOGPIXELSY), 72);
  2948. ReleaseDC(0, hDC);
  2949. lfa.lfWeight = s.fontWeight;
  2950. lfa.lfItalic = s.fItalic?-1:0;
  2951. lfa.lfUnderline = s.fUnderline?-1:0;
  2952. lfa.lfStrikeOut = s.fStrikeOut?-1:0;
  2954. return(lfa);
  2955. }
  2957. LOGFONTW& operator <<= (LOGFONTW& lfw, STSStyle& s)
  2958. {
  2959. lfw.lfCharSet = s.charSet;
  2960. #ifdef UNICODE
  2961. wcsncpy(lfw.lfFaceName, s.fontName, 32);
  2962. #else
  2963. mbstowcs(lfw.lfFaceName, s.fontName, 32);
  2964. #endif
  2965. HDC hDC = GetDC(0);
  2966. lfw.lfHeight = -MulDiv((int)(s.fontSize+0.5), GetDeviceCaps(hDC, LOGPIXELSY), 72);
  2967. ReleaseDC(0, hDC);
  2968. lfw.lfWeight = s.fontWeight;
  2969. lfw.lfItalic = s.fItalic?-1:0;
  2970. lfw.lfUnderline = s.fUnderline?-1:0;
  2971. lfw.lfStrikeOut = s.fStrikeOut?-1:0;
  2973. return(lfw);
  2974. }
  2976. CString& operator <<= (CString& style, STSStyle& s)
  2977. {
  2978. style.Format(_T("%d,%d,%d,%d,%d,%d,%f,%f,0x%06x,0x%06x,0x%06x,0x%06x,0x%02x,0x%02x,0x%02x,0x%02x,%d,%s,%f,%f,%f,%f,%d,%d,%d,%d,%d,%f,%f,%f,%d"),
  2979. s.marginRect.left,s.marginRect.right,s.marginRect.top,s.marginRect.bottom,
  2980. s.scrAlignment, s.borderStyle, s.outlineWidth, s.shadowDepth,
  2981. s.colors[0], s.colors[1], s.colors[2], s.colors[3], s.alpha[0], s.alpha[1], s.alpha[2], s.alpha[3],
  2982. s.charSet,
  2983. s.fontName, s.fontSize, s.fontScaleX, s.fontScaleY, s.fontSpacing, s.fontWeight,
  2984. (int)s.fItalic, (int)s.fUnderline, (int)s.fStrikeOut, (int)s.fBlur,
  2985. s.fontAngleZ, s.fontAngleX, s.fontAngleY,
  2986. s.relativeTo);
  2988. return(style);
  2989. }
  2991. STSStyle& operator <<= (STSStyle& s, CString& style)
  2992. {
  2993. s.SetDefault();
  2995. try 
  2996. {
  2997. CStringW str = TToW(style);
  2998. s.marginRect.left = GetInt(str); s.marginRect.right = GetInt(str); s.marginRect.top = GetInt(str); s.marginRect.bottom = GetInt(str);
  2999. s.scrAlignment = GetInt(str); s.borderStyle = GetInt(str); s.outlineWidth = GetFloat(str); s.shadowDepth = GetFloat(str);
  3000. for(int i = 0; i < 4; i++) s.colors[i] = (COLORREF)GetInt(str);
  3001. for(int i = 0; i < 4; i++) s.alpha[i] = GetInt(str);
  3002. s.charSet = GetInt(str);
  3003. s.fontName = WToT(GetStr(str)); s.fontSize = GetFloat(str); 
  3004. s.fontScaleX = GetFloat(str); s.fontScaleY = GetFloat(str);
  3005. s.fontSpacing = GetFloat(str); s.fontWeight = GetInt(str);
  3006. s.fItalic = !!GetInt(str); s.fUnderline = !!GetInt(str); s.fStrikeOut = !!GetInt(str); s.fBlur = !!GetInt(str);
  3007. s.fontAngleZ = GetFloat(str); s.fontAngleX = GetFloat(str); s.fontAngleY = GetFloat(str);
  3008. s.relativeTo = GetInt(str);
  3009. }
  3010. catch(...)
  3011. {
  3012. s.SetDefault();
  3013. }
  3015. return(s);
  3016. }