void CCharsetConverter::utf8ToStringCharset(const CStdStringA& strSource, CStdStringA& strDest)
{
if (m_iconvUtf8ToStringCharset == (iconv_t) - 1)
{
CStdString strCharset=g_langInfo.GetGuiCharSet();
m_iconvUtf8ToStringCharset = iconv_open(strCharset.c_str(), UTF8_SOURCE);
}
if (m_iconvUtf8ToStringCharset != (iconv_t) - 1)
{
const char* src = strSource.c_str();
size_t inBytes = strSource.length() + 1;
char *dst = strDest.GetBuffer(inBytes);
size_t outBytes = inBytes - 1;
if (iconv_const(m_iconvUtf8ToStringCharset, &src, &inBytes, &dst, &outBytes) == (size_t) -1)
{
strDest.ReleaseBuffer();
// For some reason it failed (maybe wrong charset?). Nothing to do but
// return the original..
strDest = strSource;
}
strDest.ReleaseBuffer();
}
}
void CCharsetConverter::utf16BEtoUTF8(const CStdStringW& strSource, CStdStringA &strDest)
{
if (m_iconvUtf16BEtoUtf8 == (iconv_t) - 1)
m_iconvUtf16BEtoUtf8 = iconv_open("UTF-8", "UTF-16BE");
if (m_iconvUtf16BEtoUtf8 != (iconv_t) - 1)
{
size_t inBytes = (strSource.length() + 1) * sizeof(wchar_t);
size_t outBytes = (strSource.length() + 1) * 4;
const char *src = (const char*) strSource.c_str();
char *dst = strDest.GetBuffer(outBytes);
if (iconv_const(m_iconvUtf16BEtoUtf8, &src, &inBytes, &dst, &outBytes))
{
CLog::Log(LOGERROR, "%s failed", __FUNCTION__);
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
if (iconv(m_iconvUtf16BEtoUtf8, NULL, NULL, &dst, &outBytes))
{
CLog::Log(LOGERROR, "%s failed cleanup", __FUNCTION__);
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
strDest.ReleaseBuffer();
}
}
void CCharsetConverter::subtitleCharsetToW(const CStdStringA& strSource, CStdStringW& strDest)
{
CStdStringA strFlipped;
// No need to flip hebrew/arabic as mplayer does the flipping
if (m_iconvSubtitleCharsetToW == (iconv_t) - 1)
{
CStdString strCharset=g_langInfo.GetSubtitleCharSet();
m_iconvSubtitleCharsetToW = iconv_open(WCHAR_CHARSET, strCharset.c_str());
}
if (m_iconvSubtitleCharsetToW != (iconv_t) - 1)
{
const char* src = strSource.c_str();
size_t inBytes = strSource.length() + 1;
char *dst = (char*)strDest.GetBuffer(inBytes * sizeof(wchar_t));
size_t outBytes = inBytes * sizeof(wchar_t);
if (iconv_const(m_iconvSubtitleCharsetToW, &src, &inBytes, &dst, &outBytes))
{
strDest.ReleaseBuffer();
// For some reason it failed (maybe wrong charset?). Nothing to do but
// return the original..
strDest = strSource;
}
strDest.ReleaseBuffer();
}
}
CStdString DocReader::ReadASCIIString(int iOffset, int iCharCount)
{
CStdStringA sResult;
ReadIntoBufferIgnoringBitsInDeletedList(iOffset, iCharCount, sResult.GetBuffer(iCharCount + 1), iCharCount+2);
sResult.ReleaseBuffer();
return sResult;
}
bool DotNetRegistrar::RegisterItem()
{
CStdString sFileName;
CStdString sParams;
CreateRegisterCommandString(sFileName, sParams);
if(_taccess(GetNameOfErrorLogFile().c_str(), 00) == 0)
_tremove(GetNameOfErrorLogFile().c_str());
CFilePath exePath( GetDotNetRegistrationFileName() ); //this was retrieved in CreateRegisterCommandString, but we want one without enclosing quotes
CStdStringA sCommand ;
sCommand.Format("\"%s\" %s", CStdStringA(exePath.GetFileName()), CStdStringA( sParams ) );
//Batch file will contain just the executable name, not path. Working directory is assumed
//by ExecuteAndWait to be the execution directory.
CStdString sBatchFile = GetExecutionPath() + _T("\\Register.bat");
_tremove( sBatchFile.c_str());
CreateTextFile( sBatchFile, sCommand );
ASSERT( CGeneral::FileExists( sBatchFile ));
ExecuteAndWait(sBatchFile, _T(""));
_tremove( sBatchFile.c_str());
if (ErrorOccurred())
{
std::vector<CStdString> Errors = GetErrorsFromFile();
std::vector<CStdString>::iterator it;
for(it = Errors.begin(); it != Errors.end(); ++it)
{
ReportEvent(EVENTLOG_ERROR_TYPE, 0, *it);
}
return false;
}
return true;
}
void CCharsetConverter::utf32ToStringCharset(const unsigned long* strSource, CStdStringA& strDest)
{
if (m_iconvUtf32ToStringCharset == (iconv_t) - 1)
{
CStdString strCharset=g_langInfo.GetGuiCharSet();
m_iconvUtf32ToStringCharset = iconv_open(strCharset.c_str(), "UTF-32LE");
}
if (m_iconvUtf32ToStringCharset != (iconv_t) - 1)
{
const unsigned long* ptr=strSource;
while (*ptr) ptr++;
const char* src = (const char*) strSource;
size_t inBytes = (ptr-strSource+1)*4;
char *dst = strDest.GetBuffer(inBytes);
size_t outBytes = inBytes;
if (iconv_const(m_iconvUtf32ToStringCharset, &src, &inBytes, &dst, &outBytes))
{
strDest.ReleaseBuffer();
// For some reason it failed (maybe wrong charset?). Nothing to do but
// return the original..
strDest = (const char *)strSource;
}
strDest.ReleaseBuffer();
}
}
void CCharsetConverter::stringCharsetToUtf8(const CStdStringA& strSource, CStdStringA& strDest)
{
if (m_iconvStringCharsetToUtf8 == (iconv_t) - 1)
{
CStdString strCharset=g_langInfo.GetGuiCharSet();
m_iconvStringCharsetToUtf8 = iconv_open("UTF-8", strCharset.c_str());
}
if (m_iconvStringCharsetToUtf8 != (iconv_t) - 1)
{
const char* src = strSource.c_str();
size_t inBytes = strSource.length() + 1;
size_t outBytes = (inBytes * 4) + 1;
char *dst = strDest.GetBuffer(outBytes);
if (iconv_const(m_iconvStringCharsetToUtf8, &src, &inBytes, &dst, &outBytes) == (size_t) -1)
{
strDest.ReleaseBuffer();
// For some reason it failed (maybe wrong charset?). Nothing to do but
// return the original..
strDest = strSource;
return ;
}
strDest.ReleaseBuffer();
}
}
void DocXDocumentStore::GetDocumentTexts(const CStdString& sFileName, std::vector<std::string>& vDocumentTexts) const
{
vDocumentTexts.clear();
CZipArchive zipArchive;
zipArchive.Open(sFileName, CZipArchive::zipOpenReadOnly);
if( !zipArchive.IsClosed() )
{
CZipWordArray ar;
zipArchive.FindMatches( L"word\\\\*.xml", ar );
for( int uIndex = 0; uIndex < ar.GetSize(); uIndex++ )
{
CZipFileHeader fhInfo;
if( zipArchive.GetFileInfo( fhInfo, ar[uIndex] ) )
{
const CZipString fileName( fhInfo.GetFileName() );
if( fileName.find_first_of( '\\' ) == fileName.find_last_of( '\\' ) )
{
C2007DocFile mf;
zipArchive.ExtractFile( ar[uIndex], mf );
const CStdStringA sDocText = mf.GetWTInnerText();
if( sDocText.size() > 0 )
vDocumentTexts.push_back( sDocText );
}
}
}
zipArchive.Flush();
zipArchive.Close();
}
}
void ActivationContextLoader::LoadDll()
{
// Get a handle to the DLL module.
CPath dllPath;
dllPath.Combine(GetModulePath(), WS_ACTIVATIONCONTEXTLOADER_DLL);
m_hinstLib = LoadLibrary(dllPath);
// If the handle is valid, try to get the function address.
if (m_hinstLib != NULL)
{
m_funcLAC = (LAC) GetProcAddress(m_hinstLib, WS_ACLOADFUNC);
m_funcULAC = (ULAC) GetProcAddress(m_hinstLib, WS_ACUNLOADFUNC);
m_funcIAAFM = (IAAFM) GetProcAddress(m_hinstLib, WS_ACALREADYACTIVEFUNC);
}
else
{
CStdStringA msg;
msg.Format("LoadLibrary on '%s'failed. Error code: %d.", WS_ACTIVATIONCONTEXTLOADER_DLL_A, GetLastError());
throw std::exception(msg);
}
}
CStdStringA RomanIndexFormatter::FormatThousands(int iValue)
{
int iThousands = iValue / 1000;
CStdStringA sResult;
sResult.resize(iThousands, 'M');
return sResult;
}
void CCharsetConverter::utf16LEtoUTF8(const void *strSource,
CStdStringA &strDest)
{
if (m_iconvUtf16LEtoUtf8 == (iconv_t) - 1)
m_iconvUtf16LEtoUtf8 = iconv_open("UTF-8", "UTF-16LE");
if (m_iconvUtf16LEtoUtf8 != (iconv_t) - 1)
{
size_t inBytes = 2;
uint16_t *s = (uint16_t *)strSource;
while (*s != 0)
{
s++;
inBytes += 2;
}
// UTF-8 is up to 4 bytes/character, or up to twice the length of UTF-16
size_t outBytes = inBytes * 2;
const char *src = (const char *)strSource;
char *dst = strDest.GetBuffer(outBytes);
if (iconv_const(m_iconvUtf16LEtoUtf8, &src, &inBytes, &dst, &outBytes) ==
(size_t)-1)
{ // failed :(
strDest.clear();
strDest.ReleaseBuffer();
return;
}
strDest.ReleaseBuffer();
}
}
bool NetworkDriveHelper::ShareTestFolder()
{
NET_API_STATUS res;
DWORD parm_err = 0;
wchar_t netName[MAX_PATH];
wchar_t path[MAX_PATH];
wchar_t remarks[MAX_PATH];
CStdStringA sTestPath = ResolveSubstDriveInPath(GET_TEST_TEMP_PATH(_T("")));
if (sTestPath.Right(1) == "\\")
sTestPath = sTestPath.Left( sTestPath.length() -1 ); // Remove last backslash.
mbstowcs( netName, TESTSHARE, MAX_PATH );
mbstowcs( path, sTestPath, MAX_PATH );
mbstowcs( remarks, "Workshare Local File Store testing share", MAX_PATH );
SHARE_INFO_2 p;
memset(&p, 0, sizeof(SHARE_INFO_2));
p.shi2_netname = netName;
p.shi2_type = STYPE_DISKTREE;
p.shi2_remark = NULL;
p.shi2_permissions = 0;
p.shi2_max_uses = -1;
p.shi2_current_uses = 0;
p.shi2_path = path;
p.shi2_passwd = NULL;
res = NetShareAdd(NULL, 2, (LPBYTE) &p, &parm_err);
if (res == NERR_DuplicateShare) // Already shared.
return true;
ASSERT(res != NERR_UnknownDevDir);
return res == 0;
}
CStdStringW RomanIndexFormatter::Render(int iValue)
{
CStdStringA sResult = FormatThousands(iValue) + FormatDigit(iValue %1000 / 100, "MDC") + FormatDigit(iValue %100 / 10, "CLX") + FormatDigit(iValue%10, "XVI");
if (m_bLowerCase)
sResult.ToLower();
return sResult;
}
CStdStringA localWideToUtf(LPCWSTR wstr)
{
if (wstr == NULL)
return "";
int bufSize = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
CStdStringA strA ("", bufSize);
if ( bufSize == 0 || WideCharToMultiByte(CP_UTF8, 0, wstr, -1, strA.GetBuf(bufSize), bufSize, NULL, NULL) != bufSize )
strA.clear();
strA.RelBuf();
return strA;
}
void TestSnapshotSaver::TestSaveBufferToTempFile()
{
const CStdString sDestFileName( SnapshotSaver::SaveBufferToTempFile( _T("This is silly data") ) );
CStdStringA sRtfBuffer;
std::ifstream file( sDestFileName );
file.get( sRtfBuffer.GetBuffer(100), 100 );
sRtfBuffer.ReleaseBuffer();
::DeleteFile( sDestFileName.c_str() );
assertTest( sRtfBuffer = _T("This is silly data") );
}
void ActivationContextLoader::UnloadDll()
{
if(m_hinstLib)
{
if (FALSE == FreeLibrary(m_hinstLib))
{
CStdStringA msg;
msg.Format("FreeLibrary on '%s'failed. Error code: %d.", WS_ACTIVATIONCONTEXTLOADER_DLL_A, GetLastError());
throw std::exception(msg);
}
}
}
void CRTFTablePostProcessor::DebugDumpStructureToFile(int iSuffix, LPCSTR szContext)
{
if (m_prtfFile->GetModality() == 0)
return;
CStdStringA csFileName;
csFileName.Format("c:\\BHTableDump%d%c.txt",iSuffix, m_prtfFile->GetModality() == 1 ? 'O' : 'M');
if(FILE *fp = fopen(csFileName, "w"))
{
fprintf( fp, "%s - Starting at %d\n", szContext, m_iStart);
m_pParentCollection->Dump(fp, true);
fclose(fp);
}
}
void ActivationContextLoader::LoadAC()
{
if (m_funcLAC)
{
DWORD dwRet = (m_funcLAC)(m_sManifest, &m_cookie);
if (ERROR_SUCCESS != dwRet)
{
CStdStringA msg;
msg.Format("Loading Activation Context with manifest '%s' failed. Error code: %d", m_sManifest.c_str(), dwRet);
throw std::exception(msg);
}
}
}
void ActivationContextLoader::UnloadAC()
{
if (m_funcULAC && m_cookie != 0)
{
DWORD dwRet = (m_funcULAC)(m_cookie);
if (ERROR_SUCCESS != dwRet)
{
CStdStringA msg;
msg.Format("Unloading Activation Context failed. Error code: %d", dwRet);
throw std::exception(msg);
}
}
}
void CCharsetConverter::ucs2CharsetToStringCharset(const CStdStringW& strSource, CStdStringA& strDest, bool swap)
{
if (m_iconvUcs2CharsetToStringCharset == (iconv_t) - 1)
{
CStdString strCharset=g_langInfo.GetGuiCharSet();
m_iconvUcs2CharsetToStringCharset = iconv_open(strCharset.c_str(), "UTF-16LE");
}
if (m_iconvUcs2CharsetToStringCharset != (iconv_t) - 1)
{
CStdStringW strCopy = strSource;
size_t inBytes = (strCopy.length() + 1) * sizeof(wchar_t);
size_t outBytes = (strCopy.length() + 1) * 4;
const char *src = (const char*)strCopy.c_str();
char *dst = strDest.GetBuffer(inBytes);
if (swap)
{
char* s = (char*) src;
while (*s || *(s + 1))
{
char c = *s;
*s = *(s + 1);
*(s + 1) = c;
s++;
s++;
}
}
if (iconv_const(m_iconvUcs2CharsetToStringCharset, &src, &inBytes, &dst, &outBytes) == (size_t)-1)
{
CLog::Log(LOGERROR, "%s failed", __FUNCTION__);
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
if (iconv_const(m_iconvUcs2CharsetToStringCharset, NULL, NULL, &dst, &outBytes) == (size_t)-1)
{
CLog::Log(LOGERROR, "%s failed cleanup", __FUNCTION__);
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
strDest.ReleaseBuffer();
}
}
CStdString CWordBinaryMetadataDiscoveryWorker::ConvertPropertyFromUTF8(CStdStringA sData)
{
CStdString sOut;
int iIncrement = 0;
int iPos = 0;
unsigned char* p = (unsigned char *)sData.GetBuffer(-1);
while (iPos < sData.GetLength())
{ // *p z y x w v u
if (*p <= 127) // 1 byte
{
sOut += *p;
iIncrement = 1;;
}
else if (*p >= 192 && *p <= 223) // 2 bytes
{ // (z-192)*64 + (y-128)
sOut += (64 * (*p - 192)) + *(p+1) - 128;
iIncrement = 2;
}
else if (*p >= 224 && *p <= 239) // 3 bytes
{ // (z-224)*4096 + (y-128)*64 + (x-128)
sOut += (4096 * (*p - 224)) + (64 * (*(p+1) - 128)) + *(p+2) - 128;
iIncrement = 3;
}
//else if (*p >= 240 && *p <= 247) // 4 bytes
//{ // (z-240)*262144 + (y-128)*4096 + (x-128)*64 + (w-128)
// sOut += (262144 * (*p - 240)) + (4096 * (*(p+1) - 128)) + (64 * (*(p+2) - 128)) + *(p+3) - 128;
// iIncrement = 4;
//}
//else if (*p >= 248 && *p <= 251) // 5 bytes
//{ // (z-248)*16777216 + (y-128)*262144 + (x-128)*4096 + (w-128)*64 + (v-128)
// sOut += (16777216 * (*p - 248)) + (262144 * (*(p+1) - 128)) + (4096 * (*(p+2) - 128)) + (64 * (*(p+3) - 128)) + *(p+4) - 128;
// iIncrement = 5;
//}
//else if (*p >= 252 && *p <= 253) // 6 bytes
//{ // (z-252)*1073741824 + (y-128)*16777216 + (x-128)*262144 + (w-128)*4096 + (v-128)*64 + (u-128)
// sOut += (1073741824 * (*p - 252)) + (16777216 * (*(p+1) - 128)) + (262144 * (*(p+2) - 128)) + (4096 * (*(p+3) - 128)) + (64 * (*(p+4) - 128)) + *(p+5) - 128;
// iIncrement = 6;
//}
else
{
// error - leave as was
return sData;
}
p += iIncrement;
iPos += iIncrement;
}
return sOut;
}
bool DotNetRegistrar::UnregisterItem()
{
CStdString sFileName;
CStdString sParams;
CreateUnregisterCommandString(sFileName, sParams);
CFilePath exePath( GetDotNetRegistrationFileName() ); //this was retrieved in CreateRegisterCommandString, but we want one without enclosing quotes
CStdStringA sCommand ;
sCommand.Format("\"%s\" %s", CStdStringA(exePath.GetFileName()), CStdStringA( sParams ) );
CStdString sBatchFile = GetExecutionPath() + _T("\\Register.bat");
_tremove( sBatchFile.c_str());
CreateTextFile( sBatchFile, sCommand );
ASSERT( CGeneral::FileExists( sBatchFile ));
bool res = true;
try
{
CStdString cmdLine = sBatchFile;
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
si.wShowWindow = SW_HIDE;
ZeroMemory(&pi, sizeof(pi));
if ( !CreateProcess( NULL, cmdLine.GetBuffer(MAX_PATH), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) )
{
cmdLine.ReleaseBuffer();
res = false;
}
cmdLine.ReleaseBuffer();
if ( res )
{
// Wait around for 15 seconds
WaitForSingleObject(pi.hProcess, 15000);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
catch(...)
{
_tremove( sBatchFile.c_str());
throw;
}
_tremove( sBatchFile.c_str());
return res;
}
CStdStringA TerDateTimeFormatter::GetFormattedTime(SYSTEMTIME& st, const CStdStringA& sFormatPicture)
{
CStdString sDate;
int ir = GetTimeFormat(m_locale, 0, &st, sFormatPicture.c_str(), sDate.GetBuffer(MAX_PATH), MAX_PATH);
sDate.ReleaseBuffer();
return sDate;
}
// The bVisualBiDiFlip forces a flip of characters for hebrew/arabic languages, only set to false if the flipping
// of the string is already made or the string is not displayed in the GUI
void CCharsetConverter::utf8ToW(const CStdStringA& utf8String, CStdStringW &wString, bool bVisualBiDiFlip/*=true*/)
{
CStdStringA strFlipped;
const char* src;
size_t inBytes;
// Try to flip hebrew/arabic characters, if any
if (bVisualBiDiFlip)
{
logicalToVisualBiDi(utf8String, strFlipped, FRIBIDI_CHAR_SET_UTF8);
src = strFlipped.c_str();
inBytes = strFlipped.length() + 1;
}
else
{
src = utf8String.c_str();
inBytes = utf8String.length() + 1;
}
if (m_iconvUtf8toW == (iconv_t) - 1)
m_iconvUtf8toW = iconv_open(WCHAR_CHARSET, UTF8_SOURCE);
if (m_iconvUtf8toW != (iconv_t) - 1)
{
size_t outBytes = inBytes * sizeof(wchar_t);
char * dst = (char*)wString.GetBuffer(outBytes);
if (iconv_const(m_iconvUtf8toW, &src, &inBytes, &dst, &outBytes) == (size_t)-1)
{
CLog::Log(LOGERROR, "%s failed", __FUNCTION__);
wString.ReleaseBuffer();
wString = utf8String;
return;
}
if (iconv(m_iconvUtf8toW, NULL, NULL, &dst, &outBytes) == (size_t)-1)
{
CLog::Log(LOGERROR, "%s failed cleanup", __FUNCTION__);
wString.ReleaseBuffer();
wString = utf8String;
return;
}
wString.ReleaseBuffer();
}
}
void CCharsetConverter::stringCharsetToUtf8(const CStdStringA& strSourceCharset, const CStdStringA& strSource, CStdStringA& strDest)
{
iconv_t iconvString=iconv_open("UTF-8", strSourceCharset.c_str());
if (iconvString != (iconv_t) - 1)
{
size_t inBytes = (strSource.length() + 1);
size_t outBytes = (strSource.length() + 1) * 4;
const char *src = strSource.c_str();
char *dst = strDest.GetBuffer(outBytes);
if (iconv_const(iconvString, &src, &inBytes, &dst, &outBytes) == (size_t) -1)
{
CLog::Log(LOGERROR, "%s failed", __FUNCTION__);
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
if (iconv(iconvString, NULL, NULL, &dst, &outBytes) == (size_t)-1)
{
CLog::Log(LOGERROR, "%s failed cleanup", __FUNCTION__);
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
strDest.ReleaseBuffer();
iconv_close(iconvString);
}
}
int IntelligentDocInfo::GetHashCode(CStdStringA sDocId)
{
if (sDocId.IsEmpty())
return 0;
DWORD dwLargeNumber(3929);
DWORD dwMultiple(dwLargeNumber); // Some large number
DWORD dwHash(0);
unsigned int iSize = sDocId.GetLength();
{
for(unsigned int i = 1; i <= iSize; ++i)
{
char c = sDocId[i-1];
dwHash += dwMultiple * i * c;
dwMultiple *= dwLargeNumber;
}
}
dwHash ^= m_iRehashCode;
return dwHash;
}
void CCharsetConverter::utf16LEtoUTF8(const CStdStringW& strSource, CStdStringA &strDest)
{
if (m_iconvUtf16LEtoUtf8 == (iconv_t) - 1)
m_iconvUtf16LEtoUtf8 = iconv_open("UTF-8", "UTF-16LE");
if (m_iconvUtf16LEtoUtf8 != (iconv_t) - 1)
{
const char* src = (const char*) strSource.c_str();
size_t inBytes = (strSource.length() + 1)*sizeof(wchar_t);
size_t outBytes = (inBytes + 1)*sizeof(wchar_t); // UTF-8 is up to 4 bytes/character
char *dst = strDest.GetBuffer(outBytes);
if (iconv_const(m_iconvUtf16LEtoUtf8, &src, &inBytes, &dst, &outBytes))
{ // failed :(
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
strDest.ReleaseBuffer();
}
}
void CCharsetConverter::ucs2CharsetToStringCharset(const CStdStringW& strSource, CStdStringA& strDest, bool swap)
{
if (m_iconvUcs2CharsetToStringCharset == (iconv_t) - 1)
{
CStdString strCharset=g_langInfo.GetGuiCharSet();
m_iconvUcs2CharsetToStringCharset = iconv_open(strCharset.c_str(), "UTF-16LE");
}
if (m_iconvUcs2CharsetToStringCharset != (iconv_t) - 1)
{
const char* src = (const char*) strSource.c_str();
size_t inBytes = (strSource.length() + 1) * sizeof(wchar_t);
if (swap)
{
char* s = (char*) src;
while (*s || *(s + 1))
{
char c = *s;
*s = *(s + 1);
*(s + 1) = c;
s++;
s++;
}
}
char *dst = strDest.GetBuffer(inBytes);
size_t outBytes = inBytes;
if (iconv_const(m_iconvUcs2CharsetToStringCharset, &src, &inBytes, &dst, &outBytes))
{
strDest.ReleaseBuffer();
// For some reason it failed (maybe wrong charset?). Nothing to do but
// return the original..
strDest = strSource;
}
strDest.ReleaseBuffer();
}
}
void CCharsetConverter::wToUTF8(const CStdStringW& strSource, CStdStringA &strDest)
{
if (m_iconvWtoUtf8 == (iconv_t) - 1)
m_iconvWtoUtf8 = iconv_open("UTF-8", WCHAR_CHARSET);
if (m_iconvWtoUtf8 != (iconv_t) - 1)
{
const char* src = (const char*) strSource.c_str();
size_t inBytes = (strSource.length() + 1) * sizeof(wchar_t);
size_t outBytes = (inBytes + 1)*sizeof(wchar_t); // some free for UTF-8 (up to 4 bytes/char)
char *dst = strDest.GetBuffer(outBytes);
if (iconv_const(m_iconvWtoUtf8, &src, &inBytes, &dst, &outBytes))
{ // failed :(
CLog::Log(LOGERROR, "CCharsetConverter::wToUTF8 failed for subtitle.");
strDest.ReleaseBuffer();
strDest = strSource;
return;
}
strDest.ReleaseBuffer();
}
}
// The bVisualBiDiFlip forces a flip of characters for hebrew/arabic languages, only set to false if the flipping
// of the string is already made or the string is not displayed in the GUI
void CCharsetConverter::utf8ToW(const CStdStringA& utf8String, CStdStringW &wString, bool bVisualBiDiFlip/*=true*/)
{
CStdStringA strFlipped;
const char* src;
size_t inBytes;
// Try to flip hebrew/arabic characters, if any
if (bVisualBiDiFlip)
{
logicalToVisualBiDi(utf8String, strFlipped, FRIBIDI_CHAR_SET_UTF8);
src = strFlipped.c_str();
inBytes = strFlipped.length() + 1;
}
else
{
src = utf8String.c_str();
inBytes = utf8String.length() + 1;
}
if (m_iconvUtf8toW == (iconv_t) - 1)
m_iconvUtf8toW = iconv_open(WCHAR_CHARSET, UTF8_SOURCE);
if (m_iconvUtf8toW != (iconv_t) - 1)
{
char *dst = new char[inBytes * sizeof(wchar_t)];
size_t outBytes = inBytes * sizeof(wchar_t);
char *outdst = dst;
if (iconv_const(m_iconvUtf8toW, &src, &inBytes, &outdst, &outBytes))
{
// For some reason it failed (maybe wrong charset?). Nothing to do but
// return the original..
wString = utf8String;
}
else
{
wString = (WCHAR *)dst;
}
delete[] dst;
}
}
