void CXRandR::LoadCustomModeLinesToAllOutputs(void)
{
/*
歌方:
1、
卦指:
1、
傍苧:
1、
*/
Query();
TiXmlDocument xmlDoc;
if (!xmlDoc.LoadFile("special://xbmc/userdata/ModeLines.xml"))
{
return;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (strcasecmp(pRootElement->Value(), "modelines") != 0)
{
// TODO ERROR
return;
}
char cmd[255];
CStdString name;
CStdString strModeLine;
for (TiXmlElement* modeline = pRootElement->FirstChildElement("modeline"); modeline; modeline = modeline->NextSiblingElement("modeline"))
{
name = modeline->Attribute("label");
name.TrimLeft(" \n\t\r");
name.TrimRight(" \n\t\r");
strModeLine = modeline->FirstChild()->Value();
strModeLine.TrimLeft(" \n\t\r");
strModeLine.TrimRight(" \n\t\r");
if (getenv("XBMC_BIN_HOME"))
{
snprintf(cmd, sizeof(cmd), "%s/xbmc-xrandr --newmode \"%s\" %s > /dev/null 2>&1", getenv("XBMC_BIN_HOME"), name.c_str(), strModeLine.c_str());
if (system(cmd) != 0)
CLog::Log(LOGERROR, "Unable to create modeline \"%s\"", name.c_str());
}
for (unsigned int i = 0; i < m_outputs.size(); i++)
{
if (getenv("XBMC_BIN_HOME"))
{
snprintf(cmd, sizeof(cmd), "%s/xbmc-xrandr --addmode %s \"%s\" > /dev/null 2>&1", getenv("XBMC_BIN_HOME"),m_outputs[i].name.c_str(), name.c_str());
if (system(cmd) != 0)
CLog::Log(LOGERROR, "Unable to add modeline \"%s\"", name.c_str());
}
}
}
}
bool ParseIPFilter(CStdString in, std::list<CStdString>* output /*=0*/)
{
bool valid = true;
in.Replace(_T("\n"), _T(" "));
in.Replace(_T("\r"), _T(" "));
in.Replace(_T("\t"), _T(" "));
while (in.Replace(_T(" "), _T(" ")));
in.TrimLeft(_T(" "));
in.TrimRight(_T(" "));
in += _T(" ");
int pos;
while ((pos = in.Find(_T(" "))) != -1)
{
CStdString ip = in.Left(pos);
if (ip == _T(""))
break;
in = in.Mid(pos + 1);
if (ip == _T("*") || IsValidAddressFilter(ip))
{
if (output)
output->push_back(ip);
}
else
valid = false;
}
return valid;
}
void PathHelper::RemoveFromPath(CStdString sPath)
{
CStdString sFullPath = GetProcessPath();
sFullPath.ToLower();
sPath.ToLower();
if ( sPath.Right(1) == _T("\\") )
{
sPath = sPath.Left(sPath.length() - 1);
}
int nStart = (x64_int_cast)sFullPath.find(sPath);
while (nStart >= 0) // there may be multiple copies
{
int nEnd = nStart + (x64_int_cast)sPath.length() + 1;
sFullPath = sFullPath.Left(nStart) + sFullPath.Right(sFullPath.length() - nEnd );
sFullPath.TrimRight();
sFullPath.TrimLeft();
if (sFullPath.Left(1) == _T(";"))
sFullPath = sFullPath.Mid(1);
sFullPath.Replace(_T(";;"),_T(";"));
nStart = (x64_int_cast)sFullPath.find(sPath);
}
SetProcessPath(sFullPath);
}
////////////////////////////////////////////////////////////////////////////////////
// Function: ExtractTimeFromIndex()
// Extracts the time information from the index string index, returning it as a value in
// milliseconds.
// Assumed format is:
// MM:SS:FF where MM is minutes, SS seconds, and FF frames (75 frames in a second)
////////////////////////////////////////////////////////////////////////////////////
int CCueDocument::ExtractTimeFromIndex(const CStdString &index)
{
// Get rid of the index number and any whitespace
CStdString numberTime = index.Mid(5);
numberTime.TrimLeft();
while (!numberTime.IsEmpty())
{
if (!isdigit(numberTime[0]))
break;
numberTime.erase(0, 1);
}
numberTime.TrimLeft();
// split the resulting string
CStdStringArray time;
StringUtils::SplitString(numberTime, ":", time);
if (time.size() != 3)
return -1;
int mins = atoi(time[0].c_str());
int secs = atoi(time[1].c_str());
int frames = atoi(time[2].c_str());
return (mins*60 + secs)*75 + frames;
}
bool CGUIDialogPluginSettings::TranslateSingleString(const CStdString &strCondition, vector<CStdString> &condVec)
{
CStdString strTest = strCondition;
strTest.ToLower();
strTest.TrimLeft(" ");
strTest.TrimRight(" ");
int pos1 = strTest.Find("(");
int pos2 = strTest.Find(",");
int pos3 = strTest.Find(")");
if (pos1 >= 0 && pos2 > pos1 && pos3 > pos2)
{
condVec.push_back(strTest.Left(pos1));
condVec.push_back(strTest.Mid(pos1 + 1, pos2 - pos1 - 1));
condVec.push_back(strTest.Mid(pos2 + 1, pos3 - pos2 - 1));
return true;
}
return false;
}
void URIUtils::CreateArchivePath(CStdString& strUrlPath,
const CStdString& strType,
const CStdString& strArchivePath,
const CStdString& strFilePathInArchive,
const CStdString& strPwd)
{
CStdString strBuffer;
strUrlPath = strType+"://";
if( !strPwd.IsEmpty() )
{
strBuffer = strPwd;
CURL::Encode(strBuffer);
strUrlPath += strBuffer;
strUrlPath += "@";
}
strBuffer = strArchivePath;
CURL::Encode(strBuffer);
strUrlPath += strBuffer;
strBuffer = strFilePathInArchive;
strBuffer.Replace('\\', '/');
strBuffer.TrimLeft('/');
strUrlPath += "/";
strUrlPath += strBuffer;
#if 0 // options are not used
strBuffer = strCachePath;
CURL::Encode(strBuffer);
strUrlPath += "?cache=";
strUrlPath += strBuffer;
strBuffer.Format("%i", wOptions);
strUrlPath += "&flags=";
strUrlPath += strBuffer;
#endif
}
IMusicInfoTagLoader* CMusicInfoTagLoaderFactory::CreateLoader(const CStdString& strFileName)
{
// dont try to read the tags for streams & shoutcast
CFileItem item(strFileName, false);
if (item.IsInternetStream())
return NULL;
if (item.IsMusicDb())
return new CMusicInfoTagLoaderDatabase();
CStdString strExtension;
URIUtils::GetExtension( strFileName, strExtension);
strExtension.ToLower();
strExtension.TrimLeft('.');
if (strExtension.IsEmpty())
return NULL;
if (strExtension == "aac" ||
strExtension == "ape" || strExtension == "mac" ||
strExtension == "mp3" ||
strExtension == "wma" ||
strExtension == "flac" ||
strExtension == "m4a" || strExtension == "mp4" ||
strExtension == "mpc" || strExtension == "mpp" || strExtension == "mp+" ||
strExtension == "ogg" || strExtension == "oga" || strExtension == "oggstream" ||
#ifdef HAS_MOD_PLAYER
ModPlayer::IsSupportedFormat(strExtension) ||
strExtension == "mod" || strExtension == "nsf" || strExtension == "nsfstream" ||
strExtension == "s3m" || strExtension == "it" || strExtension == "xm" ||
#endif
strExtension == "wv")
{
CTagLoaderTagLib *pTagLoader = new CTagLoaderTagLib();
return (IMusicInfoTagLoader*)pTagLoader;
}
#ifdef HAS_DVD_DRIVE
else if (strExtension == "cdda")
{
CMusicInfoTagLoaderCDDA *pTagLoader = new CMusicInfoTagLoaderCDDA();
return (IMusicInfoTagLoader*)pTagLoader;
}
#endif
else if (strExtension == "shn")
{
CMusicInfoTagLoaderSHN *pTagLoader = new CMusicInfoTagLoaderSHN();
return (IMusicInfoTagLoader*)pTagLoader;
}
else if (strExtension == "wav")
{
CMusicInfoTagLoaderWAV *pTagLoader = new CMusicInfoTagLoaderWAV();
return (IMusicInfoTagLoader*)pTagLoader;
}
else if (strExtension == "spc")
{
CMusicInfoTagLoaderSPC *pTagLoader = new CMusicInfoTagLoaderSPC();
return (IMusicInfoTagLoader*)pTagLoader;
}
else if (strExtension == "ym")
{
CMusicInfoTagLoaderYM *pTagLoader = new CMusicInfoTagLoaderYM();
return (IMusicInfoTagLoader*)pTagLoader;
}
#ifdef HAS_ASAP_CODEC
else if (ASAPCodec::IsSupportedFormat(strExtension) || strExtension == "asapstream")
{
CMusicInfoTagLoaderASAP *pTagLoader = new CMusicInfoTagLoaderASAP();
return (IMusicInfoTagLoader*)pTagLoader;
}
#endif
else if ( TimidityCodec::IsSupportedFormat( strExtension ) )
{
CMusicInfoTagLoaderMidi * pTagLoader = new CMusicInfoTagLoaderMidi();
return (IMusicInfoTagLoader*)pTagLoader;
}
return NULL;
}
void COptions::SetOption(int nOptionID, LPCTSTR value, bool save /*=true*/)
{
CStdString str = value;
Init();
switch (nOptionID)
{
case OPTION_SERVERPORT:
case OPTION_TLSPORTS:
{
std::set<int> portSet;
str.TrimLeft(_T(" ,"));
int pos = str.FindOneOf(_T(" ,"));
while (pos != -1)
{
int port = _ttoi(str.Left(pos));
if (port >= 1 && port <= 65535)
portSet.insert(port);
str = str.Mid(pos + 1);
str.TrimLeft(_T(" ,"));
pos = str.FindOneOf(_T(" ,"));
}
if (str != _T(""))
{
int port = _ttoi(str);
if (port >= 1 && port <= 65535)
portSet.insert(port);
}
str = _T("");
for (std::set<int>::const_iterator iter = portSet.begin(); iter != portSet.end(); iter++)
{
CStdString tmp;
tmp.Format(_T("%d "), *iter);
str += tmp;
}
str.TrimRight(' ');
}
break;
case OPTION_WELCOMEMESSAGE:
{
std::vector<CStdString> msgLines;
int oldpos = 0;
str.Replace(_T("\r\n"), _T("\n"));
int pos = str.Find(_T("\n"));
CStdString line;
while (pos != -1)
{
if (pos)
{
line = str.Mid(oldpos, pos - oldpos);
line = line.Left(CONST_WELCOMEMESSAGE_LINESIZE);
line.TrimRight(_T(" "));
if (msgLines.size() || line != _T(""))
msgLines.push_back(line);
}
oldpos = pos + 1;
pos = str.Find(_T("\n"), oldpos);
}
line = str.Mid(oldpos);
if (line != _T(""))
{
line = line.Left(CONST_WELCOMEMESSAGE_LINESIZE);
msgLines.push_back(line);
}
str = _T("");
for (unsigned int i = 0; i < msgLines.size(); i++)
str += msgLines[i] + _T("\r\n");
str.TrimRight(_T("\r\n"));
if (str == _T(""))
{
str = _T("%v");
str += _T("\r\nwritten by Tim Kosse ([email protected])");
str += _T("\r\nPlease visit https://filezilla-project.org/");
}
}
break;
case OPTION_ADMINIPBINDINGS:
{
CStdString sub;
std::list<CStdString> ipBindList;
for (unsigned int i = 0; i<_tcslen(value); i++)
{
TCHAR cur = value[i];
if ((cur < '0' || cur > '9') && cur != '.' && cur != ':')
{
if (sub == _T("") && cur == '*')
{
ipBindList.clear();
ipBindList.push_back(_T("*"));
break;
}
if (sub != _T(""))
{
if (IsIpAddress(sub))
ipBindList.push_back(sub);
sub = _T("");
}
}
else
sub += cur;
}
if (sub != _T(""))
{
if (IsIpAddress(sub))
ipBindList.push_back(sub);
}
str = _T("");
for (std::list<CStdString>::iterator iter = ipBindList.begin(); iter!=ipBindList.end(); iter++)
if (!IsLocalhost(*iter))
str += *iter + _T(" ");
str.TrimRight(_T(" "));
}
break;
case OPTION_ADMINPASS:
if (str != _T("") && str.GetLength() < 6)
return;
break;
case OPTION_MODEZ_DISALLOWED_IPS:
case OPTION_IPFILTER_ALLOWED:
case OPTION_IPFILTER_DISALLOWED:
case OPTION_ADMINIPADDRESSES:
{
str.Replace('\r', ' ');
str.Replace('\n', ' ');
str.Replace('\r', ' ');
while (str.Replace(_T(" "), _T(" ")));
str += _T(" ");
CStdString ips;
int pos = str.Find(' ');
while (pos != -1)
{
CStdString sub = str.Left(pos);
str = str.Mid(pos + 1);
str.TrimLeft(' ');
if (sub == _T("*"))
ips += _T(" ") + sub;
else
{
if (IsValidAddressFilter(sub))
ips += " " + sub;
pos = str.Find(' ');
}
}
ips.TrimLeft(' ');
str = ips;
}
break;
case OPTION_IPBINDINGS:
{
std::list<CStdString> ipBindList;
str += _T(" ");
while (!str.empty()) {
int pos = str.Find(' ');
if (pos < 0) {
break;
}
CStdString sub = str.Left(pos);
str = str.Mid(pos + 1);
if (sub == _T("*")) {
ipBindList.clear();
ipBindList.push_back(_T("*"));
break;
}
else if (IsIpAddress(sub, true)) {
ipBindList.push_back(sub);
}
}
if (ipBindList.empty())
ipBindList.push_back(_T("*"));
str.clear();
for (auto const& ip : ipBindList) {
str += ip + _T(" ");
}
str.TrimRight(_T(" "));
}
break;
case OPTION_CUSTOMPASVIPSERVER:
if (str.Find(_T("filezilla.sourceforge.net")) != -1)
str = _T("http://ip.filezilla-project.org/ip.php");
break;
}
{
simple_lock lock(m_mutex);
m_sOptionsCache[nOptionID-1].bCached = TRUE;
m_sOptionsCache[nOptionID-1].nType = 0;
m_sOptionsCache[nOptionID-1].str = str;
m_OptionsCache[nOptionID-1]=m_sOptionsCache[nOptionID-1];
}
if (!save)
return;
USES_CONVERSION;
CStdString xmlFileName = GetExecutableDirectory() + _T("FileZilla Server.xml");
char* bufferA = T2A(xmlFileName);
if (!bufferA)
return;
TiXmlDocument document;
if (!document.LoadFile(bufferA))
return;
TiXmlElement* pRoot = document.FirstChildElement("FileZillaServer");
if (!pRoot)
return;
TiXmlElement* pSettings = pRoot->FirstChildElement("Settings");
if (!pSettings)
pSettings = pRoot->LinkEndChild(new TiXmlElement("Settings"))->ToElement();
TiXmlElement* pItem;
for (pItem = pSettings->FirstChildElement("Item"); pItem; pItem = pItem->NextSiblingElement("Item"))
{
const char* pName = pItem->Attribute("name");
if (!pName)
continue;
CStdString name(pName);
if (name != m_Options[nOptionID-1].name)
continue;
break;
}
if (!pItem)
pItem = pSettings->LinkEndChild(new TiXmlElement("Item"))->ToElement();
pItem->Clear();
pItem->SetAttribute("name", ConvToNetwork(m_Options[nOptionID - 1].name).c_str());
pItem->SetAttribute("type", "string");
pItem->LinkEndChild(new TiXmlText(ConvToNetwork(value).c_str()));
document.SaveFile(bufferA);
}
//-------------------------------------------------------------------------------------------------------------------
void Xcddb::parseData(const char *buffer)
{
//writeLog("parseData Start");
char *line;
const char trenner[3] = {'\n', '\r', '\0'};
line = strtok((char*)buffer, trenner);
int line_cnt = 0;
while ((line = strtok(0, trenner)))
{
if (line[0] != '#')
{
if (0 == strncmp(line, "DTITLE", 6))
{
// DTITLE=Modern Talking / Album: Victory (The 11th Album)
unsigned int len = (unsigned int)strlen(line) - 6;
bool found = false;
unsigned int i = 5;
for (;i < len;i++)
{
if ((i + 2) <= len && line[i] == ' ' && line[i + 1] == '/' && line[i + 2] == ' ')
{
// Jep found
found = true;
break;
}
}
if (found)
{
CStdString strLine = (char*)(line + 7);
CStdString strDisk_artist = strLine.Left(i - 7);
CStdString strDisk_title = (char*)(line + i + 3);
// You never know if you really get UTF-8 strings from cddb
if (!g_charsetConverter.isValidUtf8(strDisk_artist))
g_charsetConverter.stringCharsetToUtf8(strDisk_artist, m_strDisk_artist);
else
m_strDisk_artist=strDisk_artist;
// You never know if you really get UTF-8 strings from cddb
if (!g_charsetConverter.isValidUtf8(strDisk_title))
g_charsetConverter.stringCharsetToUtf8(strDisk_title, m_strDisk_title);
else
m_strDisk_title=strDisk_title;
}
else
{
CStdString strDisk_title = (char*)(line + 7);
// You never know if you really get UTF-8 strings from cddb
if (!g_charsetConverter.isValidUtf8(strDisk_title))
g_charsetConverter.stringCharsetToUtf8(strDisk_title, m_strDisk_title);
else
m_strDisk_title=strDisk_title;
}
}
else if (0 == strncmp(line, "DYEAR", 5))
{
CStdString strYear = (char*)(line + 5);
strYear.TrimLeft("= ");
// You never know if you really get UTF-8 strings from cddb
if (!g_charsetConverter.isValidUtf8(strYear))
g_charsetConverter.stringCharsetToUtf8(strYear, m_strYear);
else
m_strYear=strYear;
}
else if (0 == strncmp(line, "DGENRE", 6))
{
CStdString strGenre = (char*)(line + 6);
strGenre.TrimLeft("= ");
// You never know if you really get UTF-8 strings from cddb
if (!g_charsetConverter.isValidUtf8(strGenre))
g_charsetConverter.stringCharsetToUtf8(strGenre, m_strGenre);
else
m_strGenre=strGenre;
}
else if (0 == strncmp(line, "TTITLE", 6))
{
addTitle(line);
}
else if (0 == strncmp(line, "EXTD", 4))
{
CStdString strExtd((char*)(line + 4));
if (m_strYear.IsEmpty())
{
// Extract Year from extended info
// as a fallback
int iPos = strExtd.Find("YEAR:");
if (iPos > -1)
{
CStdString strYear;
strYear = strExtd.Mid(iPos + 6, 4);
// You never know if you really get UTF-8 strings from cddb
if (!g_charsetConverter.isValidUtf8(strYear))
g_charsetConverter.stringCharsetToUtf8(strYear, m_strYear);
else
m_strYear=strYear;
}
}
if (m_strGenre.IsEmpty())
{
// Extract ID3 Genre
// as a fallback
int iPos = strExtd.Find("ID3G:");
if (iPos > -1)
{
CStdString strGenre;
strGenre = strExtd.Mid(iPos + 5, 4);
strGenre.TrimLeft(' ');
if (StringUtils::IsNaturalNumber(strGenre))
{
CID3Tag tag;
m_strGenre=tag.ParseMP3Genre(strGenre);
}
}
}
}
else if (0 == strncmp(line, "EXTT", 4))
{
addExtended(line);
}
}
line_cnt++;
}
//writeLog("parseData Ende");
}
////////////////////////////////////////////////////////////////////////////////////
// Function: Parse()
// Opens the .cue file for reading, and constructs the track database information
////////////////////////////////////////////////////////////////////////////////////
bool CCueDocument::Parse(const CStdString &strFile)
{
if (!m_file.Open(strFile))
return false;
CStdString strLine;
m_iTotalTracks = -1;
CStdString strCurrentFile = "";
bool bCurrentFileChanged = false;
int time;
// Run through the .CUE file and extract the tracks...
while (true)
{
if (!ReadNextLine(strLine))
break;
if (StringUtils::StartsWith(strLine,"INDEX 01"))
{
if (bCurrentFileChanged)
{
OutputDebugString("Track split over multiple files, unsupported ('" + strFile + "')\n");
return false;
}
// find the end of the number section
time = ExtractTimeFromIndex(strLine);
if (time == -1)
{ // Error!
OutputDebugString("Mangled Time in INDEX 0x tag in CUE file!\n");
return false;
}
if (m_iTotalTracks > 0) // Set the end time of the last track
m_Track[m_iTotalTracks - 1].iEndTime = time;
if (m_iTotalTracks >= 0)
m_Track[m_iTotalTracks].iStartTime = time; // start time of the next track
}
else if (StringUtils::StartsWith(strLine,"TITLE"))
{
if (m_iTotalTracks == -1) // No tracks yet
ExtractQuoteInfo(strLine, m_strAlbum);
else if (!ExtractQuoteInfo(strLine, m_Track[m_iTotalTracks].strTitle))
{
// lets manage tracks titles without quotes
CStdString titleNoQuote = strLine.Mid(5);
titleNoQuote.TrimLeft();
if (!titleNoQuote.IsEmpty())
{
g_charsetConverter.unknownToUTF8(titleNoQuote);
m_Track[m_iTotalTracks].strTitle = titleNoQuote;
}
}
}
else if (StringUtils::StartsWith(strLine,"PERFORMER"))
{
if (m_iTotalTracks == -1) // No tracks yet
ExtractQuoteInfo(strLine, m_strArtist);
else // New Artist for this track
ExtractQuoteInfo(strLine, m_Track[m_iTotalTracks].strArtist);
}
else if (StringUtils::StartsWith(strLine,"TRACK"))
{
int iTrackNumber = ExtractNumericInfo(strLine.Mid(5));
m_iTotalTracks++;
CCueTrack track;
m_Track.push_back(track);
m_Track[m_iTotalTracks].strFile = strCurrentFile;
if (iTrackNumber > 0)
m_Track[m_iTotalTracks].iTrackNumber = iTrackNumber;
else
m_Track[m_iTotalTracks].iTrackNumber = m_iTotalTracks + 1;
bCurrentFileChanged = false;
}
else if (StringUtils::StartsWith(strLine,"REM DISCNUMBER"))
{
int iDiscNumber = ExtractNumericInfo(strLine.Mid(14));
if (iDiscNumber > 0)
m_iDiscNumber = iDiscNumber;
}
else if (StringUtils::StartsWith(strLine,"FILE"))
{
// already a file name? then the time computation will be changed
if(strCurrentFile.size() > 0)
bCurrentFileChanged = true;
ExtractQuoteInfo(strLine, strCurrentFile);
// Resolve absolute paths (if needed).
if (strCurrentFile.length() > 0)
ResolvePath(strCurrentFile, strFile);
}
else if (StringUtils::StartsWith(strLine,"REM DATE"))
{
int iYear = ExtractNumericInfo(strLine.Mid(8));
if (iYear > 0)
m_iYear = iYear;
}
else if (StringUtils::StartsWith(strLine,"REM GENRE"))
{
if (!ExtractQuoteInfo(strLine, m_strGenre))
{
CStdString genreNoQuote = strLine.Mid(9);
genreNoQuote.TrimLeft();
if (!genreNoQuote.IsEmpty())
{
g_charsetConverter.unknownToUTF8(genreNoQuote);
m_strGenre = genreNoQuote;
}
}
}
else if (StringUtils::StartsWith(strLine,"REM REPLAYGAIN_ALBUM_GAIN"))
m_replayGainAlbumGain = (float)atof(strLine.Mid(26));
else if (StringUtils::StartsWith(strLine,"REM REPLAYGAIN_ALBUM_PEAK"))
m_replayGainAlbumPeak = (float)atof(strLine.Mid(26));
else if (StringUtils::StartsWith(strLine,"REM REPLAYGAIN_TRACK_GAIN") && m_iTotalTracks >= 0)
m_Track[m_iTotalTracks].replayGainTrackGain = (float)atof(strLine.Mid(26));
else if (StringUtils::StartsWith(strLine,"REM REPLAYGAIN_TRACK_PEAK") && m_iTotalTracks >= 0)
m_Track[m_iTotalTracks].replayGainTrackPeak = (float)atof(strLine.Mid(26));
}
// reset track counter to 0, and fill in the last tracks end time
m_iTrack = 0;
if (m_iTotalTracks >= 0)
m_Track[m_iTotalTracks].iEndTime = 0;
else
OutputDebugString("No INDEX 01 tags in CUE file!\n");
m_file.Close();
if (m_iTotalTracks >= 0)
{
m_iTotalTracks++;
}
return (m_iTotalTracks > 0);
}
CLinuxTimezone::CLinuxTimezone() : m_IsDST(0)
{
char* line = NULL;
size_t linelen = 0;
int nameonfourthfield = 0;
CStdString s;
vector<CStdString> tokens;
// Load timezones
FILE* fp = fopen("/usr/share/zoneinfo/zone.tab", "r");
if (fp)
{
CStdString countryCode;
CStdString timezoneName;
while (getdelim(&line, &linelen, '\n', fp) > 0)
{
tokens.clear();
s = line;
s.TrimLeft(" \t").TrimRight(" \n");
if (s.length() == 0)
continue;
if (s[0] == '#')
continue;
CUtil::Tokenize(s, tokens, " \t");
if (tokens.size() < 3)
continue;
countryCode = tokens[0];
timezoneName = tokens[2];
if (m_timezonesByCountryCode.count(countryCode) == 0)
{
vector<CStdString> timezones;
timezones.push_back(timezoneName);
m_timezonesByCountryCode[countryCode] = timezones;
}
else
{
vector<CStdString>& timezones = m_timezonesByCountryCode[countryCode];
timezones.push_back(timezoneName);
}
m_countriesByTimezoneName[timezoneName] = countryCode;
}
fclose(fp);
}
if (line)
{
free(line);
line = NULL;
linelen = 0;
}
// Load countries
fp = fopen("/usr/share/zoneinfo/iso3166.tab", "r");
if (!fp)
{
fp = fopen("/usr/share/misc/iso3166", "r");
nameonfourthfield = 1;
}
if (fp)
{
CStdString countryCode;
CStdString countryName;
while (getdelim(&line, &linelen, '\n', fp) > 0)
{
s = line;
s.TrimLeft(" \t").TrimRight(" \n");
if (s.length() == 0)
continue;
if (s[0] == '#')
continue;
// Search for the first non space from the 2nd character and on
int i = 2;
while (s[i] == ' ' || s[i] == '\t') i++;
if (nameonfourthfield)
{
// skip three letter
while (s[i] != ' ' && s[i] != '\t') i++;
while (s[i] == ' ' || s[i] == '\t') i++;
// skip number
while (s[i] != ' ' && s[i] != '\t') i++;
while (s[i] == ' ' || s[i] == '\t') i++;
}
countryCode = s.Left(2);
countryName = s.Mid(i);
m_counties.push_back(countryName);
m_countryByCode[countryCode] = countryName;
m_countryByName[countryName] = countryCode;
}
sort(m_counties.begin(), m_counties.end(), sortstringbyname());
fclose(fp);
}
free(line);
}
bool PVRIptvData::LoadPlayList(void)
{
if (m_strM3uUrl.IsEmpty())
{
XBMC->Log(LOG_NOTICE, "Playlist file path is not configured. Channels not loaded.");
return false;
}
CStdString strPlaylistContent;
if (!GetCachedFileContents(M3U_FILE_NAME, m_strM3uUrl, strPlaylistContent))
{
XBMC->Log(LOG_ERROR, "Unable to load playlist file '%s': file is missing or empty.", m_strM3uUrl.c_str());
return false;
}
std::stringstream stream(strPlaylistContent);
/* load channels */
bool bFirst = true;
int iUniqueChannelId = 0;
int iUniqueGroupId = 0;
int iCurrentGroupId = 0;
int iChannelNum = 0;
int iEPGTimeShift = 0;
PVRIptvChannel tmpChannel;
tmpChannel.strTvgId = "";
tmpChannel.strChannelName = "";
tmpChannel.strTvgName = "";
tmpChannel.strTvgLogo = "";
tmpChannel.iTvgShift = 0;
char szLine[1024];
while(stream.getline(szLine, 1024))
{
CStdString strLine = "";
strLine.append(szLine);
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
if (strLine.IsEmpty())
{
continue;
}
if (bFirst)
{
bFirst = false;
if (strLine.Left(3) == "\xEF\xBB\xBF")
{
strLine.Delete(0, 3);
}
if (strLine.Left((int)strlen(M3U_START_MARKER)) == M3U_START_MARKER)
{
double fTvgShift = atof(ReadMarkerValue(strLine, TVG_INFO_SHIFT_MARKER));
iEPGTimeShift = (int) (fTvgShift * 3600.0);
continue;
}
else
{
break;
}
}
if (strLine.Left((int)strlen(M3U_INFO_MARKER)) == M3U_INFO_MARKER)
{
bool bRadio = false;
double fTvgShift = 0;
CStdString strChnlName = "";
CStdString strTvgId = "";
CStdString strTvgName = "";
CStdString strTvgLogo = "";
CStdString strGroupName = "";
CStdString strRadio = "";
// parse line
int iColon = (int)strLine.Find(':');
int iComma = (int)strLine.ReverseFind(',');
if (iColon >= 0 && iComma >= 0 && iComma > iColon)
{
// parse name
iComma++;
strChnlName = strLine.Right((int)strLine.size() - iComma).Trim();
tmpChannel.strChannelName = XBMC->UnknownToUTF8(strChnlName);
// parse info
CStdString strInfoLine = strLine.Mid(++iColon, --iComma - iColon);
strTvgId = ReadMarkerValue(strInfoLine, TVG_INFO_ID_MARKER);
strTvgName = ReadMarkerValue(strInfoLine, TVG_INFO_NAME_MARKER);
strTvgLogo = ReadMarkerValue(strInfoLine, TVG_INFO_LOGO_MARKER);
strGroupName = ReadMarkerValue(strInfoLine, GROUP_NAME_MARKER);
strRadio = ReadMarkerValue(strInfoLine, RADIO_MARKER);
fTvgShift = atof(ReadMarkerValue(strInfoLine, TVG_INFO_SHIFT_MARKER));
if (strTvgId.IsEmpty())
{
char buff[255];
sprintf(buff, "%d", atoi(strInfoLine));
strTvgId.append(buff);
}
if (strTvgLogo.IsEmpty())
{
strTvgLogo = strChnlName;
}
bRadio = !strRadio.CompareNoCase("true");
tmpChannel.strTvgId = strTvgId;
tmpChannel.strTvgName = XBMC->UnknownToUTF8(strTvgName);
tmpChannel.strTvgLogo = XBMC->UnknownToUTF8(strTvgLogo);
tmpChannel.iTvgShift = (int)(fTvgShift * 3600.0);
tmpChannel.bRadio = bRadio;
if (tmpChannel.iTvgShift == 0 && iEPGTimeShift != 0)
{
tmpChannel.iTvgShift = iEPGTimeShift;
}
if (!strGroupName.IsEmpty())
{
strGroupName = XBMC->UnknownToUTF8(strGroupName);
PVRIptvChannelGroup * pGroup;
if ((pGroup = FindGroup(strGroupName)) == NULL)
{
PVRIptvChannelGroup group;
group.strGroupName = strGroupName;
group.iGroupId = ++iUniqueGroupId;
group.bRadio = bRadio;
m_groups.push_back(group);
iCurrentGroupId = iUniqueGroupId;
}
else
{
iCurrentGroupId = pGroup->iGroupId;
}
}
}
}
else if (strLine[0] != '#')
{
PVRIptvChannel channel;
channel.iUniqueId = ++iUniqueChannelId;
channel.iChannelNumber = ++iChannelNum;
channel.strTvgId = tmpChannel.strTvgId;
channel.strChannelName = tmpChannel.strChannelName;
channel.strTvgName = tmpChannel.strTvgName;
channel.strTvgLogo = tmpChannel.strTvgLogo;
channel.iTvgShift = tmpChannel.iTvgShift;
channel.bRadio = tmpChannel.bRadio;
channel.strStreamURL = strLine;
channel.iEncryptionSystem = 0;
if (iCurrentGroupId > 0)
{
channel.bRadio = m_groups.at(iCurrentGroupId - 1).bRadio;
m_groups.at(iCurrentGroupId - 1).members.push_back(channel.iChannelNumber);
}
m_channels.push_back(channel);
tmpChannel.strTvgId = "";
tmpChannel.strChannelName = "";
tmpChannel.strTvgName = "";
tmpChannel.strTvgLogo = "";
tmpChannel.iTvgShift = 0;
tmpChannel.bRadio = false;
}
}
stream.clear();
if (m_channels.size() == 0)
{
XBMC->Log(LOG_ERROR, "Unable to load channels from file '%s': file is corrupted.", m_strM3uUrl.c_str());
return false;
}
ApplyChannelsLogos();
XBMC->Log(LOG_NOTICE, "Loaded %d channels.", m_channels.size());
return true;
}
CStdString CID3Tag::ParseMP3Genre(const CStdString& str) const
{
m_dll.Load();
CStdString strTemp = str;
set<CStdString> setGenres;
while (!strTemp.IsEmpty())
{
// remove any leading spaces
strTemp.TrimLeft();
if (strTemp.IsEmpty())
break;
// start off looking for (something)
if (strTemp[0] == '(')
{
strTemp.erase(0, 1);
if (strTemp.empty())
break;
// now look for ((something))
if (strTemp[0] == '(')
{
// remove ((something))
int i = strTemp.find_first_of(')');
strTemp.erase(0, i + 2);
}
}
// no parens, so we have a start of a string
// push chars into temp string until valid terminator found
// valid terminators are ) or , or ;
else
{
CStdString t;
size_t i = strTemp.find_first_of("),;");
if (i != std::string::npos)
{
t = strTemp.Left(i);
strTemp.erase(0, i + 1);
} else {
t = strTemp;
strTemp.clear();
}
// remove any leading or trailing white space
// from temp string
t.Trim();
if (!t.length()) continue;
// if the temp string is natural number try to convert it to a genre string
if (StringUtils::IsNaturalNumber(t))
{
id3_ucs4_t* ucs4=m_dll.id3_latin1_ucs4duplicate((id3_latin1_t*)t.c_str());
const id3_ucs4_t* genre=m_dll.id3_genre_name(ucs4);
m_dll.id3_ucs4_free(ucs4);
t=ToStringCharset(genre, ID3_FIELD_TEXTENCODING_ISO_8859_1);
}
// convert RX to Remix as per ID3 V2.3 spec
else if ((t == "RX") || (t == "Rx") || (t == "rX") || (t == "rx"))
{
t = "Remix";
}
// convert CR to Cover as per ID3 V2.3 spec
else if ((t == "CR") || (t == "Cr") || (t == "cR") || (t == "cr"))
{
t = "Cover";
}
// insert genre name in set
setGenres.insert(t);
}
}
// return a " / " seperated string
CStdString strGenre;
set<CStdString>::iterator it;
for (it = setGenres.begin(); it != setGenres.end(); it++)
{
CStdString strTemp = *it;
if (!strGenre.IsEmpty())
strGenre += g_advancedSettings.m_musicItemSeparator;
strGenre += strTemp;
}
return strGenre;
}
bool CPlayListPLS::Load(const CStdString &strFile)
{
//read it from the file
CStdString strFileName(strFile);
m_strPlayListName = URIUtils::GetFileName(strFileName);
Clear();
bool bShoutCast = false;
if( strFileName.Left(8).Equals("shout://") )
{
strFileName.Delete(0, 8);
strFileName.Insert(0, "http://");
m_strBasePath = "";
bShoutCast = true;
}
else
URIUtils::GetParentPath(strFileName, m_strBasePath);
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return false;
}
if (file.GetLength() > 1024*1024)
{
CLog::Log(LOGWARNING, "%s - File is larger than 1 MB, most likely not a playlist",__FUNCTION__);
return false;
}
char szLine[4096];
CStdString strLine;
// run through looking for the [playlist] marker.
// if we find another http stream, then load it.
while (1)
{
if ( !file.ReadString(szLine, sizeof(szLine) ) )
{
file.Close();
return size() > 0;
}
strLine = szLine;
strLine.TrimLeft(" \t");
strLine.TrimRight(" \n\r");
if(strLine.Equals(START_PLAYLIST_MARKER))
break;
// if there is something else before playlist marker, this isn't a pls file
if(!strLine.IsEmpty())
return false;
}
bool bFailed = false;
while (file.ReadString(szLine, sizeof(szLine) ) )
{
strLine = szLine;
StringUtils::RemoveCRLF(strLine);
int iPosEqual = strLine.Find("=");
if (iPosEqual > 0)
{
CStdString strLeft = strLine.Left(iPosEqual);
iPosEqual++;
CStdString strValue = strLine.Right(strLine.size() - iPosEqual);
strLeft.ToLower();
while (strLeft[0] == ' ' || strLeft[0] == '\t')
strLeft.erase(0,1);
if (strLeft == "numberofentries")
{
m_vecItems.reserve(atoi(strValue.c_str()));
}
else if (strLeft.Left(4) == "file")
{
vector <int>::size_type idx = atoi(strLeft.c_str() + 4);
if (!Resize(idx))
{
bFailed = true;
break;
}
// Skip self - do not load playlist recursively
if (URIUtils::GetFileName(strValue).Equals(URIUtils::GetFileName(strFileName)))
continue;
if (m_vecItems[idx - 1]->GetLabel().empty())
m_vecItems[idx - 1]->SetLabel(URIUtils::GetFileName(strValue));
CFileItem item(strValue, false);
if (bShoutCast && !item.IsAudio())
strValue.Replace("http:", "shout:");
strValue = URIUtils::SubstitutePath(strValue);
CUtil::GetQualifiedFilename(m_strBasePath, strValue);
g_charsetConverter.unknownToUTF8(strValue);
m_vecItems[idx - 1]->SetPath(strValue);
}
else if (strLeft.Left(5) == "title")
{
vector <int>::size_type idx = atoi(strLeft.c_str() + 5);
if (!Resize(idx))
{
bFailed = true;
break;
}
g_charsetConverter.unknownToUTF8(strValue);
m_vecItems[idx - 1]->SetLabel(strValue);
}
else if (strLeft.Left(6) == "length")
{
vector <int>::size_type idx = atoi(strLeft.c_str() + 6);
if (!Resize(idx))
{
bFailed = true;
break;
}
m_vecItems[idx - 1]->GetMusicInfoTag()->SetDuration(atol(strValue.c_str()));
}
else if (strLeft == "playlistname")
{
m_strPlayListName = strValue;
g_charsetConverter.unknownToUTF8(m_strPlayListName);
}
}
}
file.Close();
if (bFailed)
{
CLog::Log(LOGERROR, "File %s is not a valid PLS playlist. Location of first file,title or length is not permitted (eg. File0 should be File1)", URIUtils::GetFileName(strFileName).c_str());
return false;
}
// check for missing entries
ivecItems p = m_vecItems.begin();
while ( p != m_vecItems.end())
{
if ((*p)->GetPath().empty())
{
p = m_vecItems.erase(p);
}
else
{
++p;
}
}
return true;
}
void CNetworkInterfaceLinux::SetSettings(NetworkAssignment& assignment, CStdString& ipAddress, CStdString& networkMask, CStdString& defaultGateway, CStdString& essId, CStdString& key, EncMode& encryptionMode)
{
#ifndef __APPLE__
FILE* fr = fopen("/etc/network/interfaces", "r");
if (!fr)
{
// TODO
return;
}
FILE* fw = fopen("/tmp/interfaces.temp", "w");
if (!fw)
{
// TODO
return;
}
char* line = NULL;
size_t linel = 0;
CStdString s;
bool foundInterface = false;
bool dataWritten = false;
while (getdelim(&line, &linel, '\n', fr) > 0)
{
vector<CStdString> tokens;
s = line;
s.TrimLeft(" \t").TrimRight(" \n");
// skip comments
if (!foundInterface && (s.length() == 0 || s.GetAt(0) == '#'))
{
fprintf(fw, "%s", line);
continue;
}
// look for "iface <interface name> inet"
CUtil::Tokenize(s, tokens, " ");
if (tokens.size() == 2 &&
tokens[0].Equals("auto") &&
tokens[1].Equals(GetName()))
{
continue;
}
else if (!foundInterface &&
tokens.size() == 4 &&
tokens[0].Equals("iface") &&
tokens[1].Equals(GetName()) &&
tokens[2].Equals("inet"))
{
foundInterface = true;
WriteSettings(fw, assignment, ipAddress, networkMask, defaultGateway, essId, key, encryptionMode);
dataWritten = true;
}
else if (foundInterface &&
tokens.size() == 4 &&
tokens[0].Equals("iface"))
{
foundInterface = false;
fprintf(fw, "%s", line);
}
else if (!foundInterface)
{
fprintf(fw, "%s", line);
}
}
if (line)
free(line);
if (!dataWritten && assignment != NETWORK_DISABLED)
{
fprintf(fw, "\n");
WriteSettings(fw, assignment, ipAddress, networkMask, defaultGateway, essId, key, encryptionMode);
}
fclose(fr);
fclose(fw);
// Rename the file
// NEUROS: Since on the Link we have sudo setup with no password, this will always work
system("sudo cp /tmp/interfaces.temp /etc/network/interfaces");
CLog::Log(LOGINFO, "Stopping interface %s", GetName().c_str());
std::string cmd = "sudo /sbin/ifdown " + GetName();
system(cmd.c_str());
if (assignment != NETWORK_DISABLED)
{
CLog::Log(LOGINFO, "Starting interface %s", GetName().c_str());
cmd = "sudo /sbin/ifup " + GetName();
system(cmd.c_str());
}
#endif
}
void CNetworkInterfaceLinux::GetSettings(NetworkAssignment& assignment, CStdString& ipAddress, CStdString& networkMask, CStdString& defaultGateway, CStdString& essId, CStdString& key, EncMode& encryptionMode)
{
ipAddress = "0.0.0.0";
networkMask = "0.0.0.0";
defaultGateway = "0.0.0.0";
essId = "";
key = "";
encryptionMode = ENC_NONE;
assignment = NETWORK_DISABLED;
#if defined(TARGET_LINUX)
FILE* fp = fopen("/etc/network/interfaces", "r");
if (!fp)
{
// TODO
return;
}
char* line = NULL;
size_t linel = 0;
CStdString s;
bool foundInterface = false;
while (getdelim(&line, &linel, '\n', fp) > 0)
{
vector<CStdString> tokens;
s = line;
s.TrimLeft(" \t").TrimRight(" \n");
// skip comments
if (s.length() == 0 || s.GetAt(0) == '#')
continue;
// look for "iface <interface name> inet"
CUtil::Tokenize(s, tokens, " ");
if (!foundInterface &&
tokens.size() >=3 &&
tokens[0].Equals("iface") &&
tokens[1].Equals(GetName()) &&
tokens[2].Equals("inet"))
{
if (tokens[3].Equals("dhcp"))
{
assignment = NETWORK_DHCP;
foundInterface = true;
}
if (tokens[3].Equals("static"))
{
assignment = NETWORK_STATIC;
foundInterface = true;
}
}
if (foundInterface && tokens.size() == 2)
{
if (tokens[0].Equals("address")) ipAddress = tokens[1];
else if (tokens[0].Equals("netmask")) networkMask = tokens[1];
else if (tokens[0].Equals("gateway")) defaultGateway = tokens[1];
else if (tokens[0].Equals("wireless-essid")) essId = tokens[1];
else if (tokens[0].Equals("wireless-key"))
{
key = tokens[1];
if (key.length() > 2 && key[0] == 's' && key[1] == ':')
key.erase(0, 2);
encryptionMode = ENC_WEP;
}
else if (tokens[0].Equals("wpa-ssid")) essId = tokens[1];
else if (tokens[0].Equals("wpa-proto") && tokens[1].Equals("WPA")) encryptionMode = ENC_WPA;
else if (tokens[0].Equals("wpa-proto") && tokens[1].Equals("WPA2")) encryptionMode = ENC_WPA2;
else if (tokens[0].Equals("wpa-psk")) key = tokens[1];
else if (tokens[0].Equals("auto") || tokens[0].Equals("iface") || tokens[0].Equals("mapping")) break;
}
}
free(line);
// Fallback in case wpa-proto is not set
if (key != "" && encryptionMode == ENC_NONE)
encryptionMode = ENC_WPA;
fclose(fp);
#endif
}
bool CShoutcastDirectory::ParseStations(TiXmlElement *root, CFileItemList &items, CURL &url)
{
TiXmlElement *element = NULL;
CStdString path;
items.m_idepth = 2; /* station list */
element = root->FirstChildElement("tunein");
if(element == NULL)
{
CLog::Log(LOGWARNING, "%s - No tunein base found", __FUNCTION__);
return false;
}
path = element->Attribute("base");
path.TrimLeft("/");
url.SetFileName(path);
element = root->FirstChildElement("station");
if(element == NULL)
{
CLog::Log(LOGWARNING, "%s - No stations found", __FUNCTION__);
return false;
}
int stations = 0;
while(element != NULL && stations < 1000)
{
CStdString name = element->Attribute("name");
CStdString id = element->Attribute("id");
CStdString bitrate = element->Attribute("br");
CStdString genre = element->Attribute("genre");
CStdString listeners = element->Attribute("lc");
CStdString content = element->Attribute("mt");
CStdString label = name;
url.SetOptions("?id=" + id);
url.GetURL(path);
//printf("%s: %s\n", name.c_str(), path.c_str());
CFileItem* pItem = new CFileItem;
pItem->m_bIsFolder = false;
/* we highjack the music tag for this stuff, they will be used by */
/* viewstates to sort and display proper information */
pItem->GetMusicInfoTag()->SetArtist(listeners);
pItem->GetMusicInfoTag()->SetAlbum(bitrate);
pItem->GetMusicInfoTag()->SetGenre(genre);
/* this is what will be sorted upon */
pItem->GetVideoInfoTag()->m_fRating = (float)atoi(listeners.c_str());
pItem->m_dwSize = atoi(bitrate.c_str());
pItem->SetLabel(label);
/* content type is known before hand, should save later lookup */
/* wonder if we could combine the contentype of the playlist and of the real stream */
pItem->SetContentType("audio/x-scpls");
pItem->m_strPath = path;
items.Add(pItem);
stations++;
element = element->NextSiblingElement("station");
}
return true;
}
CStdString CPlayListM3U::GetBestBandwidthStream(const CStdString &strFileName, size_t bandwidth)
{
// we may be passed a playlist that does not contain playlists of different
// bitrates (eg: this playlist is really the HLS video). So, default the
// return to the filename so it can be played
char szLine[4096];
CStdString strLine;
CStdString strPlaylist = strFileName;
size_t maxBandwidth = 0;
// if we cannot get the last / we wont be able to determine the sub-playlists
size_t baseEnd = strPlaylist.rfind('/');
if (baseEnd == std::string::npos)
return strPlaylist;
// store the base path (the path without the filename)
CStdString basePath = strPlaylist.substr(0, baseEnd + 1);
// open the file, and if it fails, return
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return strPlaylist;
}
// convert bandwidth specified in kbps to bps used by the m3u8
bandwidth *= 1000;
while (file.ReadString(szLine, 1024))
{
// read and trim a line
strLine = szLine;
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
// skip the first line
if (strLine == M3U_START_MARKER)
continue;
else if (strLine.Left(strlen(M3U_STREAM_MARKER)) == M3U_STREAM_MARKER)
{
// parse the line so we can pull out the bandwidth
std::map< CStdString, CStdString > params = ParseStreamLine(strLine);
std::map< CStdString, CStdString >::iterator it = params.find(M3U_BANDWIDTH_MARKER);
if (it != params.end())
{
size_t streamBandwidth = atoi(it->second.c_str());
if ((maxBandwidth < streamBandwidth) && (streamBandwidth <= bandwidth))
{
// read the next line
if (!file.ReadString(szLine, 1024))
continue;
strLine = szLine;
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
// this line was empty
if (strLine.empty())
continue;
// store the max bandwidth
maxBandwidth = streamBandwidth;
// if the path is absolute just use it
if (CURL::IsFullPath(strLine))
strPlaylist = strLine;
else
strPlaylist = basePath + strLine;
}
}
}
}
CLog::Log(LOGINFO, "Auto-selecting %s based on configured bandwidth.", strPlaylist.c_str());
return strPlaylist;
}
bool CTagLoaderTagLib::Load(const string& strFileName, CMusicInfoTag& tag, EmbeddedArt *art /* = NULL */)
{
CStdString strExtension;
URIUtils::GetExtension(strFileName, strExtension);
strExtension.ToLower();
strExtension.TrimLeft('.');
if (strExtension.IsEmpty())
return false;
TagLibVFSStream* stream = new TagLibVFSStream(strFileName, true);
if (!stream)
{
CLog::Log(LOGERROR, "could not create TagLib VFS stream for: %s", strFileName.c_str());
return false;
}
TagLib::File* file = NULL;
TagLib::APE::File* apeFile = NULL;
TagLib::ASF::File* asfFile = NULL;
TagLib::FLAC::File* flacFile = NULL;
TagLib::IT::File* itFile = NULL;
TagLib::Mod::File* modFile = NULL;
TagLib::MP4::File* mp4File = NULL;
TagLib::MPC::File* mpcFile = NULL;
TagLib::MPEG::File* mpegFile = NULL;
TagLib::Ogg::Vorbis::File* oggVorbisFile = NULL;
TagLib::Ogg::FLAC::File* oggFlacFile = NULL;
TagLib::S3M::File* s3mFile = NULL;
TagLib::TrueAudio::File* ttaFile = NULL;
TagLib::WavPack::File* wvFile = NULL;
TagLib::XM::File* xmFile = NULL;
if (strExtension == "ape")
file = apeFile = new APE::File(stream);
else if (strExtension == "asf" || strExtension == "wmv" || strExtension == "wma")
file = asfFile = new ASF::File(stream);
else if (strExtension == "flac")
file = flacFile = new FLAC::File(stream, ID3v2::FrameFactory::instance());
else if (strExtension == "it")
file = itFile = new IT::File(stream);
else if (strExtension == "mod" || strExtension == "module" || strExtension == "nst" || strExtension == "wow")
file = modFile = new Mod::File(stream);
else if (strExtension == "mp4" || strExtension == "m4a" ||
strExtension == "m4r" || strExtension == "m4b" ||
strExtension == "m4p" || strExtension == "3g2")
file = mp4File = new MP4::File(stream);
else if (strExtension == "mpc")
file = mpcFile = new MPC::File(stream);
else if (strExtension == "mp3" || strExtension == "aac")
file = mpegFile = new MPEG::File(stream, ID3v2::FrameFactory::instance());
else if (strExtension == "s3m")
file = s3mFile = new S3M::File(stream);
else if (strExtension == "tta")
file = ttaFile = new TrueAudio::File(stream, ID3v2::FrameFactory::instance());
else if (strExtension == "wv")
file = wvFile = new WavPack::File(stream);
else if (strExtension == "xm")
file = xmFile = new XM::File(stream);
else if (strExtension == "ogg")
file = oggVorbisFile = new Ogg::Vorbis::File(stream);
else if (strExtension == "oga") // Leave this madness until last - oga container can have Vorbis or FLAC
{
file = oggFlacFile = new Ogg::FLAC::File(stream);
if (!file || !file->isValid())
{
delete file;
file = oggVorbisFile = new Ogg::Vorbis::File(stream);
}
}
if (!file || !file->isOpen())
{
delete file;
delete stream;
CLog::Log(LOGDEBUG, "file could not be opened for tag reading");
return false;
}
APE::Tag *ape = NULL;
ASF::Tag *asf = NULL;
MP4::Tag *mp4 = NULL;
ID3v2::Tag *id3v2 = NULL;
Ogg::XiphComment *xiph = NULL;
Tag *generic = NULL;
if (apeFile)
ape = apeFile->APETag(false);
else if (asfFile)
asf = asfFile->tag();
else if (flacFile)
{
xiph = flacFile->xiphComment(false);
id3v2 = flacFile->ID3v2Tag(false);
}
else if (mp4File)
mp4 = mp4File->tag();
else if (mpegFile)
{
id3v2 = mpegFile->ID3v2Tag(false);
ape = mpegFile->APETag(false);
}
else if (oggFlacFile)
xiph = dynamic_cast<Ogg::XiphComment *>(oggFlacFile->tag());
else if (oggVorbisFile)
xiph = dynamic_cast<Ogg::XiphComment *>(oggVorbisFile->tag());
else if (ttaFile)
id3v2 = ttaFile->ID3v2Tag(false);
else if (wvFile)
ape = wvFile->APETag(false);
else // This is a catch all to get generic information for other files types (s3m, xm, it, mod, etc)
generic = file->tag();
if (file->audioProperties())
tag.SetDuration(file->audioProperties()->length());
if (ape && !g_advancedSettings.m_prioritiseAPEv2tags)
ParseAPETag(ape, art, tag);
if (asf)
ParseASF(asf, art, tag);
else if (id3v2)
ParseID3v2Tag(id3v2, art, tag);
else if (generic)
ParseGenericTag(generic, art, tag);
else if (mp4)
ParseMP4Tag(mp4, art, tag);
else if (xiph)
ParseXiphComment(xiph, art, tag);
// art for flac files is outside the tag
if (flacFile)
SetFlacArt(flacFile, art, tag);
// Add APE tags over the top of ID3 tags if we want to prioritize them
if (ape && g_advancedSettings.m_prioritiseAPEv2tags)
ParseAPETag(ape, art, tag);
if (!tag.GetTitle().IsEmpty() || !tag.GetArtist().empty() || !tag.GetAlbum().IsEmpty())
tag.SetLoaded();
tag.SetURL(strFileName);
delete file;
delete stream;
return true;
}
bool CPlayListM3U::Load(const CStdString& strFileName)
{
char szLine[4096];
CStdString strLine;
CStdString strInfo = "";
long lDuration = 0;
Clear();
m_strPlayListName = URIUtils::GetFileName(strFileName);
URIUtils::GetParentPath(strFileName, m_strBasePath);
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return false;
}
while (file.ReadString(szLine, 1024))
{
strLine = szLine;
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
if (strLine.Left( (int)strlen(M3U_INFO_MARKER) ) == M3U_INFO_MARKER)
{
// start of info
int iColon = (int)strLine.find(":");
int iComma = (int)strLine.find(",");
if (iColon >= 0 && iComma >= 0 && iComma > iColon)
{
// Read the info and duration
iColon++;
CStdString strLength = strLine.Mid(iColon, iComma - iColon);
lDuration = atoi(strLength.c_str());
iComma++;
strInfo = strLine.Right((int)strLine.size() - iComma);
g_charsetConverter.unknownToUTF8(strInfo);
}
}
else if (strLine != M3U_START_MARKER && strLine.Left(strlen(M3U_ARTIST_MARKER)) != M3U_ARTIST_MARKER && strLine.Left(strlen(M3U_ALBUM_MARKER)) != M3U_ALBUM_MARKER )
{
CStdString strFileName = strLine;
if (strFileName.size() > 0 && strFileName[0] == '#')
continue; // assume a comment or something else we don't support
// Skip self - do not load playlist recursively
if (URIUtils::GetFileName(strFileName).Equals(m_strPlayListName))
continue;
if (strFileName.length() > 0)
{
g_charsetConverter.unknownToUTF8(strFileName);
// If no info was read from from the extended tag information, use the file name
if (strInfo.length() == 0)
{
strInfo = URIUtils::GetFileName(strFileName);
}
// should substitition occur befor or after charset conversion??
strFileName = URIUtils::SubstitutePath(strFileName);
// Get the full path file name and add it to the the play list
CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
CFileItemPtr newItem(new CFileItem(strInfo));
newItem->SetPath(strFileName);
if (lDuration && newItem->IsAudio())
newItem->GetMusicInfoTag()->SetDuration(lDuration);
Add(newItem);
// Reset the values just in case there part of the file have the extended marker
// and part don't
strInfo = "";
lDuration = 0;
}
}
}
file.Close();
return true;
}
void CNetworkInterfaceLinux::SetSettings(NetworkAssignment& assignment, CStdString& ipAddress, CStdString& networkMask, CStdString& defaultGateway, CStdString& essId, CStdString& key, EncMode& encryptionMode)
{
#if defined(TARGET_LINUX)
FILE* fr = fopen("/etc/network/interfaces", "r");
if (!fr)
{
// TODO
return;
}
FILE* fw = fopen("/tmp/interfaces.temp", "w");
if (!fw)
{
// TODO
fclose(fr);
return;
}
char* line = NULL;
size_t linel = 0;
CStdString s;
bool foundInterface = false;
bool dataWritten = false;
while (getdelim(&line, &linel, '\n', fr) > 0)
{
vector<CStdString> tokens;
s = line;
s.TrimLeft(" \t").TrimRight(" \n");
// skip comments
if (!foundInterface && (s.length() == 0 || s.GetAt(0) == '#'))
{
fprintf(fw, "%s", line);
continue;
}
// look for "iface <interface name> inet"
CUtil::Tokenize(s, tokens, " ");
if (tokens.size() == 2 &&
tokens[0].Equals("auto") &&
tokens[1].Equals(GetName()))
{
continue;
}
else if (!foundInterface &&
tokens.size() == 4 &&
tokens[0].Equals("iface") &&
tokens[1].Equals(GetName()) &&
tokens[2].Equals("inet"))
{
foundInterface = true;
WriteSettings(fw, assignment, ipAddress, networkMask, defaultGateway, essId, key, encryptionMode);
dataWritten = true;
}
else if (foundInterface &&
tokens.size() == 4 &&
tokens[0].Equals("iface"))
{
foundInterface = false;
fprintf(fw, "%s", line);
}
else if (!foundInterface)
{
fprintf(fw, "%s", line);
}
}
free(line);
if (!dataWritten && assignment != NETWORK_DISABLED)
{
fprintf(fw, "\n");
WriteSettings(fw, assignment, ipAddress, networkMask, defaultGateway, essId, key, encryptionMode);
}
fclose(fr);
fclose(fw);
// Rename the file
if (rename("/tmp/interfaces.temp", "/etc/network/interfaces") < 0)
{
// TODO
return;
}
std::string cmd = "/sbin/ifdown " + GetName();
if (system(cmd.c_str()) != 0)
CLog::Log(LOGERROR, "Unable to stop interface %s", GetName().c_str());
else
CLog::Log(LOGINFO, "Stopped interface %s", GetName().c_str());
if (assignment != NETWORK_DISABLED)
{
cmd = "/sbin/ifup " + GetName();
if (system(cmd.c_str()) != 0)
CLog::Log(LOGERROR, "Unable to start interface %s", GetName().c_str());
else
CLog::Log(LOGINFO, "Started interface %s", GetName().c_str());
}
#endif
}
void CScraperParser::RemoveWhiteSpace(CStdString &string)
{
string.TrimLeft(" \t\r\n");
string.TrimRight(" \t\r\n");
}
//-------------------------------------------------------------------------------------------------------------------
void Xcddb::parseData(const char *buffer)
{
//writeLog("parseData Start");
std::map<CStdString, CStdString> keywords;
std::list<CStdString> keywordsOrder; // remember order of keywords as it appears in data received from CDDB
// Collect all the keywords and put them in map.
// Multiple occurrences of the same keyword indicate that
// the data contained on those lines should be concatenated
char *line;
const char trenner[3] = {'\n', '\r', '\0'};
line = strtok((char*)buffer, trenner); // skip first line
while ((line = strtok(0, trenner)))
{
// Lines that begin with # are comments, should be ignored
if (line[0] != '#')
{
char *s = strstr(line, "=");
if (s != NULL)
{
CStdString strKeyword(line, s - line);
strKeyword.TrimRight(" ");
CStdString strValue(s+1);
strValue.Replace("\\n", "\n");
strValue.Replace("\\t", "\t");
strValue.Replace("\\\\", "\\");
g_charsetConverter.unknownToUTF8(strValue);
std::map<CStdString, CStdString>::const_iterator it = keywords.find(strKeyword);
if (it != keywords.end())
strValue = it->second + strValue; // keyword occured before, concatenate
else
keywordsOrder.push_back(strKeyword);
keywords[strKeyword] = strValue;
}
}
}
// parse keywords
for (std::list<CStdString>::const_iterator it = keywordsOrder.begin(); it != keywordsOrder.end(); ++it)
{
CStdString strKeyword = *it;
CStdString strValue = keywords[strKeyword];
if (strKeyword == "DTITLE")
{
// DTITLE may contain artist and disc title, separated with " / ",
// for example: DTITLE=Modern Talking / Album: Victory (The 11th Album)
bool found = false;
for (int i = 0; i < strValue.GetLength() - 2; i++)
{
if (strValue[i] == ' ' && strValue[i + 1] == '/' && strValue[i + 2] == ' ')
{
m_strDisk_artist = TrimToUTF8(strValue.Left(i));
m_strDisk_title = TrimToUTF8(strValue.Mid(i+3));
found = true;
break;
}
}
if (!found)
m_strDisk_title = TrimToUTF8(strValue);
}
else if (strKeyword == "DYEAR")
m_strYear = TrimToUTF8(strValue);
else if (strKeyword== "DGENRE")
m_strGenre = TrimToUTF8(strValue);
else if (strKeyword.Left(6) == "TTITLE")
addTitle(strKeyword + "=" + strValue);
else if (strKeyword == "EXTD")
{
CStdString strExtd(strValue);
if (m_strYear.IsEmpty())
{
// Extract Year from extended info
// as a fallback
int iPos = strExtd.Find("YEAR:");
if (iPos > -1) // You never know if you really get UTF-8 strings from cddb
g_charsetConverter.unknownToUTF8(strExtd.Mid(iPos + 6, 4), m_strYear);
}
if (m_strGenre.IsEmpty())
{
// Extract ID3 Genre
// as a fallback
int iPos = strExtd.Find("ID3G:");
if (iPos > -1)
{
CStdString strGenre = strExtd.Mid(iPos + 5, 4);
strGenre.TrimLeft(' ');
if (StringUtils::IsNaturalNumber(strGenre))
{
CID3Tag tag;
m_strGenre=tag.ParseMP3Genre(strGenre);
}
}
}
}
else if (strKeyword.Left(4) == "EXTT")
addExtended(strKeyword + "=" + strValue);
}
//writeLog("parseData Ende");
}
CStdString DvSaveFormatConverter::NormaliseExtension(CStdString sExtension)
{
sExtension.TrimLeft(L'.');
sExtension.Normalize();
return sExtension;
}