forked from mia/Aegisub
772 lines
18 KiB
C++
772 lines
18 KiB
C++
/*
|
|
* Copyright (C) 2003-2006 Gabest
|
|
* http://www.gabest.org
|
|
*
|
|
* This Program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This Program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNU Make; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
* http://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
*/
|
|
|
|
#include "StdAfx.h"
|
|
#include "usfsubtitles.h"
|
|
|
|
#define DeclareNameAndValue(pNode, name, val) \
|
|
CComBSTR name; \
|
|
pNode->get_nodeName(&name); \
|
|
name.ToLower(); \
|
|
CComVariant val; \
|
|
pNode->get_nodeValue(&val); \
|
|
|
|
#define BeginEnumAttribs(pNode, pChild, name, value) \
|
|
{CComPtr<IXMLDOMNamedNodeMap> pAttribs; \
|
|
if(SUCCEEDED(pNode->get_attributes(&pAttribs)) && pAttribs != NULL) \
|
|
{ \
|
|
CComPtr<IXMLDOMNode> pChild; \
|
|
for(pAttribs->nextNode(&pChild); pChild; pChild = NULL, pAttribs->nextNode(&pChild)) \
|
|
{ \
|
|
|
|
#define EndEnumAttribs }}}
|
|
|
|
#define BeginEnumChildren(pNode, pChild) \
|
|
{CComPtr<IXMLDOMNode> pChild, pNext; \
|
|
for(pNode->get_firstChild(&pChild); pChild; pNext = NULL, pChild->get_nextSibling(&pNext), pChild = pNext) \
|
|
{ \
|
|
|
|
#define EndEnumChildren }}
|
|
|
|
static CStringW GetText(CComPtr<IXMLDOMNode> pNode)
|
|
{
|
|
CComBSTR bstr;
|
|
pNode->get_text(&bstr);
|
|
|
|
return(CStringW(bstr));
|
|
}
|
|
|
|
static CStringW GetXML(CComPtr<IXMLDOMNode> pNode)
|
|
{
|
|
CComBSTR bstr;
|
|
pNode->get_xml(&bstr);
|
|
CStringW str(bstr);
|
|
str.Remove('\r');
|
|
str.Replace('\n', ' ');
|
|
for(int i = 0; (i = str.Find(L" ", i)) >= 0; )
|
|
{
|
|
for(++i; i < str.GetLength() && (str[i] == '\n' || str[i] == ' ');)
|
|
str.Delete(i);
|
|
}
|
|
return(str);
|
|
}
|
|
|
|
static CStringW GetAttrib(CStringW attrib, CComPtr<IXMLDOMNode> pNode)
|
|
{
|
|
CStringW ret;
|
|
|
|
BeginEnumAttribs(pNode, pChild, name, val)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(CStringW(name) == attrib && val.vt == VT_BSTR) // TODO: prepare for other types
|
|
{
|
|
ret = val.bstrVal;
|
|
break;
|
|
}
|
|
}
|
|
EndEnumAttribs
|
|
|
|
return(ret);
|
|
}
|
|
|
|
static int TimeToInt(CStringW str)
|
|
{
|
|
CAtlList<CStringW> sl;
|
|
int i = 0;
|
|
for(CStringW token = str.Tokenize(L":.,", i); !token.IsEmpty(); token = str.Tokenize(L":.,", i))
|
|
sl.AddHead(token);
|
|
|
|
if(sl.GetCount() > 4)
|
|
return(-1);
|
|
|
|
int time = 0;
|
|
|
|
int mul[4] = {1,1000,60*1000,60*60*1000};
|
|
POSITION pos = sl.GetHeadPosition();
|
|
for(i = 0; pos; i++)
|
|
{
|
|
const WCHAR* s = sl.GetNext(pos);
|
|
WCHAR* tmp = NULL;
|
|
int t = wcstol(s, &tmp, 10);
|
|
if(s >= tmp) return(-1);
|
|
time += t * mul[i];
|
|
}
|
|
|
|
return(time);
|
|
}
|
|
|
|
static DWORD StringToDWORD(CStringW str)
|
|
{
|
|
if(str.IsEmpty()) return(0);
|
|
if(str[0] == '#') return((DWORD)wcstol(str, NULL, 16));
|
|
else return((DWORD)wcstol(str, NULL, 10));
|
|
}
|
|
|
|
static DWORD ColorToDWORD(CStringW str)
|
|
{
|
|
if(str.IsEmpty()) return(0);
|
|
|
|
DWORD ret = 0;
|
|
|
|
if(str[0] == '#')
|
|
{
|
|
ret = (DWORD)wcstol(str.TrimLeft('#'), NULL, 16);
|
|
}
|
|
else
|
|
{
|
|
g_colors.Lookup(CString(str), ret);
|
|
}
|
|
|
|
ret = ((ret&0xff)<<16)|(ret&0xff00ff00)|((ret>>16)&0xff);
|
|
|
|
return(ret);
|
|
}
|
|
|
|
static int TranslateAlignment(CStringW alignment)
|
|
{
|
|
return
|
|
!alignment.CompareNoCase(L"BottomLeft") ? 1 :
|
|
!alignment.CompareNoCase(L"BottomCenter") ? 2 :
|
|
!alignment.CompareNoCase(L"BottomRight") ? 3 :
|
|
!alignment.CompareNoCase(L"MiddleLeft") ? 4 :
|
|
!alignment.CompareNoCase(L"MiddleCenter") ? 5 :
|
|
!alignment.CompareNoCase(L"MiddleRight") ? 6 :
|
|
!alignment.CompareNoCase(L"TopLeft") ? 7 :
|
|
!alignment.CompareNoCase(L"TopCenter") ? 8 :
|
|
!alignment.CompareNoCase(L"TopRight") ? 9 :
|
|
2;
|
|
}
|
|
|
|
static int TranslateMargin(CStringW margin, int wndsize)
|
|
{
|
|
int ret = 0;
|
|
|
|
if(!margin.IsEmpty())
|
|
{
|
|
ret = wcstol(margin, NULL, 10);
|
|
if(margin.Find('%') >= 0) ret = wndsize * ret / 100;
|
|
}
|
|
|
|
return(ret);
|
|
}
|
|
|
|
////////////////
|
|
|
|
CUSFSubtitles::CUSFSubtitles()
|
|
{
|
|
}
|
|
|
|
CUSFSubtitles::~CUSFSubtitles()
|
|
{
|
|
}
|
|
|
|
bool CUSFSubtitles::Read(LPCTSTR fn)
|
|
{
|
|
VARIANT_BOOL vb;
|
|
CComPtr<IXMLDOMDocument> pDoc;
|
|
if(FAILED(pDoc.CoCreateInstance(CLSID_DOMDocument))
|
|
|| FAILED(pDoc->put_async(VARIANT_FALSE))
|
|
|| FAILED(pDoc->load(CComVariant(fn), &vb)) || vb != VARIANT_TRUE)
|
|
return(false);
|
|
|
|
styles.RemoveAll();
|
|
effects.RemoveAll();
|
|
texts.RemoveAll();
|
|
|
|
if(!ParseUSFSubtitles(CComQIPtr<IXMLDOMNode>(pDoc)))
|
|
return(false);
|
|
|
|
POSITION pos = styles.GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
style_t* def = styles.GetNext(pos);
|
|
|
|
if(def->name.CompareNoCase(L"Default"))
|
|
continue;
|
|
|
|
POSITION pos2 = styles.GetHeadPosition();
|
|
while(pos2)
|
|
{
|
|
style_t* s = styles.GetNext(pos2);
|
|
|
|
if(!s->name.CompareNoCase(L"Default"))
|
|
continue;
|
|
|
|
if(s->fontstyle.face.IsEmpty()) s->fontstyle.face = def->fontstyle.face;
|
|
if(s->fontstyle.size.IsEmpty()) s->fontstyle.size = def->fontstyle.size;
|
|
if(s->fontstyle.color[0].IsEmpty()) s->fontstyle.color[0] = def->fontstyle.color[0];
|
|
if(s->fontstyle.color[1].IsEmpty()) s->fontstyle.color[1] = def->fontstyle.color[1];
|
|
if(s->fontstyle.color[2].IsEmpty()) s->fontstyle.color[2] = def->fontstyle.color[2];
|
|
if(s->fontstyle.color[3].IsEmpty()) s->fontstyle.color[3] = def->fontstyle.color[3];
|
|
if(s->fontstyle.italic.IsEmpty()) s->fontstyle.italic = def->fontstyle.italic;
|
|
if(s->fontstyle.weight.IsEmpty()) s->fontstyle.weight = def->fontstyle.weight;
|
|
if(s->fontstyle.underline.IsEmpty()) s->fontstyle.underline = def->fontstyle.underline;
|
|
if(s->fontstyle.alpha.IsEmpty()) s->fontstyle.alpha = def->fontstyle.alpha;
|
|
if(s->fontstyle.outline.IsEmpty()) s->fontstyle.outline = def->fontstyle.outline;
|
|
if(s->fontstyle.shadow.IsEmpty()) s->fontstyle.shadow = def->fontstyle.shadow;
|
|
if(s->fontstyle.wrap.IsEmpty()) s->fontstyle.wrap = def->fontstyle.wrap;
|
|
if(s->pal.alignment.IsEmpty()) s->pal.alignment = def->pal.alignment;
|
|
if(s->pal.relativeto.IsEmpty()) s->pal.relativeto = def->pal.relativeto;
|
|
if(s->pal.horizontal_margin.IsEmpty()) s->pal.horizontal_margin = def->pal.horizontal_margin;
|
|
if(s->pal.vertical_margin.IsEmpty()) s->pal.vertical_margin = def->pal.vertical_margin;
|
|
if(s->pal.rotate[0].IsEmpty()) s->pal.rotate[0] = def->pal.rotate[0];
|
|
if(s->pal.rotate[1].IsEmpty()) s->pal.rotate[1] = def->pal.rotate[1];
|
|
if(s->pal.rotate[2].IsEmpty()) s->pal.rotate[2] = def->pal.rotate[2];
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
pos = texts.GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
text_t* t = texts.GetNext(pos);
|
|
if(t->style.IsEmpty()) t->style = L"Default";
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool CUSFSubtitles::ConvertToSTS(CSimpleTextSubtitle& sts)
|
|
{
|
|
sts.m_name = metadata.language.text;
|
|
sts.m_encoding = CTextFile::UTF8;
|
|
sts.m_dstScreenSize = CSize(640, 480);
|
|
sts.m_fScaledBAS = true;
|
|
sts.m_defaultWrapStyle = 1;
|
|
|
|
// TODO: map metadata.language.code to charset num (windows doesn't have such a function...)
|
|
int charSet = DEFAULT_CHARSET;
|
|
|
|
POSITION pos = styles.GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
style_t* s = styles.GetNext(pos);
|
|
|
|
if(!s->name.CompareNoCase(L"Default") && !s->fontstyle.wrap.IsEmpty())
|
|
{
|
|
sts.m_defaultWrapStyle =
|
|
!s->fontstyle.wrap.CompareNoCase(L"no") ? 2 :
|
|
!s->fontstyle.wrap.CompareNoCase(L"auto") ? 1 :
|
|
1;
|
|
}
|
|
|
|
STSStyle* stss = new STSStyle;
|
|
if(!stss) continue;
|
|
|
|
if(!s->pal.horizontal_margin.IsEmpty())
|
|
stss->marginRect.left = stss->marginRect.right = TranslateMargin(s->pal.horizontal_margin, sts.m_dstScreenSize.cx);
|
|
if(!s->pal.vertical_margin.IsEmpty())
|
|
stss->marginRect.top = stss->marginRect.bottom = TranslateMargin(s->pal.vertical_margin, sts.m_dstScreenSize.cy);
|
|
|
|
stss->scrAlignment = TranslateAlignment(s->pal.alignment);
|
|
|
|
if(!s->pal.relativeto.IsEmpty()) stss->relativeTo =
|
|
!s->pal.relativeto.CompareNoCase(L"window") ? 0 :
|
|
!s->pal.relativeto.CompareNoCase(L"video") ? 1 :
|
|
0;
|
|
|
|
stss->borderStyle = 0;
|
|
if(!s->fontstyle.outline.IsEmpty()) stss->outlineWidth = wcstol(s->fontstyle.outline, NULL, 10);
|
|
if(!s->fontstyle.shadow.IsEmpty()) stss->shadowDepth = wcstol(s->fontstyle.shadow, NULL, 10);
|
|
|
|
for(int i = 0; i < 4; i++)
|
|
{
|
|
DWORD color = ColorToDWORD(s->fontstyle.color[i]);
|
|
int alpha = (BYTE)wcstol(s->fontstyle.alpha, NULL, 10);
|
|
|
|
stss->colors[i] = color & 0xffffff;
|
|
stss->alpha[i] = (BYTE)(color>>24);
|
|
|
|
stss->alpha[i] = stss->alpha[i] + (255 - stss->alpha[i]) * min(max(alpha, 0), 100) / 100;
|
|
}
|
|
|
|
if(!s->fontstyle.face.IsEmpty()) stss->fontName = s->fontstyle.face;
|
|
if(!s->fontstyle.size.IsEmpty()) stss->fontSize = wcstol(s->fontstyle.size, NULL, 10);
|
|
if(!s->fontstyle.weight.IsEmpty()) stss->fontWeight =
|
|
!s->fontstyle.weight.CompareNoCase(L"normal") ? FW_NORMAL :
|
|
!s->fontstyle.weight.CompareNoCase(L"bold") ? FW_BOLD :
|
|
!s->fontstyle.weight.CompareNoCase(L"lighter") ? FW_LIGHT :
|
|
!s->fontstyle.weight.CompareNoCase(L"bolder") ? FW_SEMIBOLD :
|
|
wcstol(s->fontstyle.weight, NULL, 10);
|
|
if(stss->fontWeight == 0) stss->fontWeight = FW_NORMAL;
|
|
if(!s->fontstyle.italic.IsEmpty()) stss->fItalic = s->fontstyle.italic.CompareNoCase(L"yes") == 0;
|
|
if(!s->fontstyle.underline.IsEmpty()) stss->fUnderline = s->fontstyle.underline.CompareNoCase(L"yes") == 0;
|
|
if(!s->pal.rotate[0].IsEmpty()) stss->fontAngleZ = wcstol(s->pal.rotate[0], NULL, 10);
|
|
if(!s->pal.rotate[1].IsEmpty()) stss->fontAngleX = wcstol(s->pal.rotate[1], NULL, 10);
|
|
if(!s->pal.rotate[2].IsEmpty()) stss->fontAngleY = wcstol(s->pal.rotate[2], NULL, 10);
|
|
|
|
stss->charSet = charSet;
|
|
|
|
sts.AddStyle(WToT(s->name), stss);
|
|
}
|
|
|
|
pos = texts.GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
text_t* t = texts.GetNext(pos);
|
|
|
|
if(!t->pal.alignment.IsEmpty())
|
|
{
|
|
CStringW s;
|
|
s.Format(L"{\\an%d}", TranslateAlignment(t->pal.alignment));
|
|
t->str = s + t->str;
|
|
}
|
|
|
|
CRect marginRect;
|
|
marginRect.SetRectEmpty();
|
|
|
|
if(!t->pal.horizontal_margin.IsEmpty())
|
|
marginRect.left = marginRect.right = TranslateMargin(t->pal.horizontal_margin, sts.m_dstScreenSize.cx);
|
|
if(!t->pal.vertical_margin.IsEmpty())
|
|
marginRect.top = marginRect.bottom = TranslateMargin(t->pal.vertical_margin, sts.m_dstScreenSize.cy);
|
|
|
|
WCHAR rtags[3][8] = {L"{\\rz%d}", L"{\\rx%d}", L"{\\ry%d}"};
|
|
for(int i = 0; i < 3; i++)
|
|
{
|
|
if(int angle = wcstol(t->pal.rotate[i], NULL, 10))
|
|
{
|
|
CStringW str;
|
|
str.Format(rtags[i], angle);
|
|
t->str = str + t->str;
|
|
}
|
|
}
|
|
|
|
if(t->style.CompareNoCase(L"Default") != 0)
|
|
{
|
|
POSITION pos = styles.GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
style_t* s = styles.GetNext(pos);
|
|
if(s->name == t->style && !s->fontstyle.wrap.IsEmpty())
|
|
{
|
|
int WrapStyle =
|
|
!s->fontstyle.wrap.CompareNoCase(L"no") ? 2 :
|
|
!s->fontstyle.wrap.CompareNoCase(L"auto") ? 1 :
|
|
1;
|
|
|
|
if(WrapStyle != sts.m_defaultWrapStyle)
|
|
{
|
|
CStringW str;
|
|
str.Format(L"{\\q%d}", WrapStyle);
|
|
t->str = str + t->str;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: apply effects as {\t(..)} after usf's standard clearly defines them
|
|
|
|
sts.Add(t->str, true, t->start, t->stop, WToT(t->style), _T(""), _T(""), marginRect);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool CUSFSubtitles::ParseUSFSubtitles(CComPtr<IXMLDOMNode> pNode)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
if(name == L"usfsubtitles")
|
|
{
|
|
// metadata
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(name == L"metadata")
|
|
{
|
|
ParseMetadata(pChild, metadata);
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
|
|
// styles
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(name == L"styles")
|
|
{
|
|
BeginEnumChildren(pChild, pGrandChild) // :)
|
|
{
|
|
DeclareNameAndValue(pGrandChild, name, val);
|
|
|
|
if(name == L"style")
|
|
{
|
|
CAutoPtr<style_t> s(new style_t);
|
|
if(s)
|
|
{
|
|
ParseStyle(pGrandChild, s);
|
|
styles.AddTail(s);
|
|
}
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
|
|
// effects
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(name == L"effects")
|
|
{
|
|
BeginEnumChildren(pChild, pGrandChild) // :)
|
|
{
|
|
DeclareNameAndValue(pGrandChild, name, val);
|
|
|
|
if(name == L"effect")
|
|
{
|
|
CAutoPtr<effect_t> e(new effect_t);
|
|
if(e)
|
|
{
|
|
ParseEffect(pGrandChild, e);
|
|
effects.AddTail(e);
|
|
}
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
|
|
// subtitles
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(name == L"subtitles")
|
|
{
|
|
BeginEnumChildren(pChild, pGrandChild) // :)
|
|
{
|
|
DeclareNameAndValue(pGrandChild, name, val);
|
|
|
|
if(name == L"subtitle")
|
|
{
|
|
CStringW sstart = GetAttrib(L"start", pGrandChild);
|
|
CStringW sstop = GetAttrib(L"stop", pGrandChild);
|
|
CStringW sduration = GetAttrib(L"duration", pGrandChild);
|
|
if(sstart.IsEmpty() || (sstop.IsEmpty() && sduration.IsEmpty()))
|
|
continue;
|
|
|
|
int start = TimeToInt(sstart);
|
|
int stop = !sstop.IsEmpty() ? TimeToInt(sstop) : (start + TimeToInt(sduration));
|
|
|
|
ParseSubtitle(pGrandChild, start, stop);
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
|
|
return(true);
|
|
}
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
if(ParseUSFSubtitles(pChild))
|
|
{
|
|
return(true);
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
|
|
return(false);
|
|
}
|
|
|
|
void CUSFSubtitles::ParseMetadata(CComPtr<IXMLDOMNode> pNode, metadata_t& m)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
if(name == L"title")
|
|
{
|
|
m.title = GetText(pNode);
|
|
}
|
|
else if(name == L"date")
|
|
{
|
|
m.date = GetText(pNode);
|
|
}
|
|
else if(name == L"comment")
|
|
{
|
|
m.comment = GetText(pNode);
|
|
}
|
|
else if(name == L"author")
|
|
{
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(name == L"name")
|
|
m.author.name = GetText(pChild);
|
|
else if(name == L"email")
|
|
m.author.email = GetText(pChild);
|
|
else if(name == L"url")
|
|
m.author.url = GetText(pChild);
|
|
}
|
|
EndEnumChildren
|
|
|
|
return;
|
|
}
|
|
else if(name == L"language")
|
|
{
|
|
m.language.text = GetText(pNode);
|
|
m.language.code = GetAttrib(L"code", pNode);
|
|
}
|
|
else if(name == L"languageext")
|
|
{
|
|
m.languageext.text = GetText(pNode);
|
|
m.languageext.code = GetAttrib(L"code", pNode);
|
|
}
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
ParseMetadata(pChild, metadata);
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
|
|
void CUSFSubtitles::ParseStyle(CComPtr<IXMLDOMNode> pNode, style_t* s)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
if(name == L"style")
|
|
{
|
|
s->name = GetAttrib(L"name", pNode);
|
|
}
|
|
else if(name == L"fontstyle")
|
|
{
|
|
ParseFontstyle(pNode, s->fontstyle);
|
|
return;
|
|
}
|
|
else if(name == L"position")
|
|
{
|
|
ParsePal(pNode, s->pal);
|
|
return;
|
|
}
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
ParseStyle(pChild, s);
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
|
|
void CUSFSubtitles::ParseFontstyle(CComPtr<IXMLDOMNode> pNode, fontstyle_t& fs)
|
|
{
|
|
fs.face = GetAttrib(L"face", pNode);
|
|
fs.size = GetAttrib(L"size", pNode);
|
|
fs.color[0] = GetAttrib(L"color", pNode);
|
|
fs.color[1] = GetAttrib(L"back-color", pNode);
|
|
fs.color[2] = GetAttrib(L"outline-color", pNode);
|
|
fs.color[3] = GetAttrib(L"shadow-color", pNode);
|
|
fs.italic = GetAttrib(L"italic", pNode);
|
|
fs.weight = GetAttrib(L"weight", pNode);
|
|
fs.underline = GetAttrib(L"underline", pNode);
|
|
fs.alpha = GetAttrib(L"alpha", pNode);
|
|
fs.outline = GetAttrib(L"outline-level", pNode);
|
|
fs.shadow = GetAttrib(L"shadow-level", pNode);
|
|
fs.wrap = GetAttrib(L"wrap", pNode);
|
|
}
|
|
|
|
void CUSFSubtitles::ParsePal(CComPtr<IXMLDOMNode> pNode, posattriblist_t& pal)
|
|
{
|
|
pal.alignment = GetAttrib(L"alignment", pNode);
|
|
pal.relativeto = GetAttrib(L"relative-to", pNode);
|
|
pal.horizontal_margin = GetAttrib(L"horizontal-margin", pNode);
|
|
pal.vertical_margin = GetAttrib(L"vertical-margin", pNode);
|
|
pal.rotate[0] = GetAttrib(L"rotate-z", pNode);
|
|
pal.rotate[1] = GetAttrib(L"rotate-x", pNode);
|
|
pal.rotate[2] = GetAttrib(L"rotate-y", pNode);
|
|
}
|
|
|
|
void CUSFSubtitles::ParseEffect(CComPtr<IXMLDOMNode> pNode, effect_t* e)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
if(name == L"effect")
|
|
{
|
|
e->name = GetAttrib(L"name", pNode);
|
|
}
|
|
else if(name == L"keyframes")
|
|
{
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
DeclareNameAndValue(pChild, name, val);
|
|
|
|
if(name == L"keyframe")
|
|
{
|
|
CAutoPtr<keyframe_t> k(new keyframe_t);
|
|
if(k)
|
|
{
|
|
ParseKeyframe(pChild, k);
|
|
e->keyframes.AddTail(k);
|
|
}
|
|
}
|
|
}
|
|
EndEnumChildren
|
|
|
|
return;
|
|
}
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
ParseEffect(pChild, e);
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
|
|
void CUSFSubtitles::ParseKeyframe(CComPtr<IXMLDOMNode> pNode, keyframe_t* k)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
if(name == L"keyframe")
|
|
{
|
|
k->position = GetAttrib(L"position", pNode);
|
|
}
|
|
else if(name == L"fontstyle")
|
|
{
|
|
ParseFontstyle(pNode, k->fontstyle);
|
|
return;
|
|
}
|
|
else if(name == L"position")
|
|
{
|
|
ParsePal(pNode, k->pal);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CUSFSubtitles::ParseSubtitle(CComPtr<IXMLDOMNode> pNode, int start, int stop)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
if(name == L"text" || name == L"karaoke")
|
|
{
|
|
CAutoPtr<text_t> t(new text_t);
|
|
if(t)
|
|
{
|
|
t->start = start;
|
|
t->stop = stop;
|
|
t->style = GetAttrib(L"style", pNode);
|
|
t->effect = GetAttrib(L"effect", pNode);
|
|
ParsePal(pNode, t->pal);
|
|
ParseText(pNode, t->str);
|
|
texts.AddTail(t);
|
|
}
|
|
|
|
return;
|
|
}
|
|
// else if
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
ParseSubtitle(pChild, start, stop);
|
|
}
|
|
EndEnumChildren
|
|
}
|
|
|
|
void CUSFSubtitles::ParseText(CComPtr<IXMLDOMNode> pNode, CStringW& str)
|
|
{
|
|
DeclareNameAndValue(pNode, name, val);
|
|
|
|
CStringW prefix, postfix;
|
|
|
|
if(name == L"b")
|
|
{
|
|
prefix = L"{\\b1}";
|
|
postfix = L"{\\b}";
|
|
}
|
|
else if(name == L"i")
|
|
{
|
|
prefix = L"{\\i1}";
|
|
postfix = L"{\\i}";
|
|
}
|
|
else if(name == L"u")
|
|
{
|
|
prefix = L"{\\u1}";
|
|
postfix = L"{\\u}";
|
|
}
|
|
else if(name == L"font")
|
|
{
|
|
fontstyle_t fs;
|
|
ParseFontstyle(pNode, fs);
|
|
|
|
if(!fs.face.IsEmpty()) {prefix += L"{\\fn" + fs.face + L"}"; postfix += L"{\\fn}";}
|
|
if(!fs.size.IsEmpty()) {prefix += L"{\\fs" + fs.size + L"}"; postfix += L"{\\fs}";}
|
|
if(!fs.outline.IsEmpty()) {prefix += L"{\\bord" + fs.outline + L"}"; postfix += L"{\\bord}";}
|
|
if(!fs.shadow.IsEmpty()) {prefix += L"{\\shad" + fs.shadow + L"}"; postfix += L"{\\shad}";}
|
|
|
|
for(int i = 0; i < 4; i++)
|
|
{
|
|
if(!fs.color[i].IsEmpty())
|
|
{
|
|
CStringW s;
|
|
s.Format(L"{\\%dc&H%06x&}", i+1, ColorToDWORD(fs.color[i]));
|
|
prefix += s;
|
|
s.Format(L"{\\%dc}", i+1);
|
|
postfix += s;
|
|
}
|
|
}
|
|
}
|
|
else if(name == L"k")
|
|
{
|
|
int t = wcstol(GetAttrib(L"t", pNode), NULL, 10);
|
|
CStringW s;
|
|
s.Format(L"{\\kf%d}", t / 10);
|
|
str += s;
|
|
return;
|
|
}
|
|
else if(name == L"br")
|
|
{
|
|
str += L"\\N";
|
|
return;
|
|
}
|
|
else if(name == L"#text")
|
|
{
|
|
str += GetXML(pNode);
|
|
return;
|
|
}
|
|
|
|
BeginEnumChildren(pNode, pChild)
|
|
{
|
|
CStringW s;
|
|
ParseText(pChild, s);
|
|
str += s;
|
|
}
|
|
EndEnumChildren
|
|
|
|
str = prefix + str + postfix;
|
|
}
|
|
|
|
void CUSFSubtitles::ParseShape(CComPtr<IXMLDOMNode> pNode)
|
|
{
|
|
// no specs on this yet
|
|
}
|