void CScraperParser::ReplaceBuffers(CStdString& strDest)
{
// insert buffers
int iIndex;
for (int i=MAX_SCRAPER_BUFFERS-1; i>=0; i--)
{
CStdString temp;
iIndex = 0;
temp.Format("$$%i",i+1);
while ((size_t)(iIndex = strDest.find(temp,iIndex)) != CStdString::npos) // COPIED FROM CStdString WITH THE ADDITION OF $ ESCAPING
{
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iIndex+temp.GetLength(),m_param[i]);
iIndex += m_param[i].length();
}
}
// insert settings
iIndex = 0;
while ((size_t)(iIndex = strDest.find("$INFO[",iIndex)) != CStdString::npos)
{
int iEnd = strDest.Find("]",iIndex);
CStdString strInfo = strDest.Mid(iIndex+6,iEnd-iIndex-6);
CStdString strReplace;
if (m_scraper)
strReplace = m_scraper->GetSetting(strInfo);
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iEnd+1,strReplace);
iIndex += strReplace.length();
}
iIndex = 0;
while ((size_t)(iIndex = strDest.find("\\n",iIndex)) != CStdString::npos)
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iIndex+2,"\n");
}
void CScraperParser::ConvertJSON(CStdString &string)
{
CRegExp reg;
reg.RegComp("\\\\u([0-f]{4})");
while (reg.RegFind(string.c_str()) > -1)
{
int pos = reg.GetSubStart(1);
std::string szReplace(reg.GetMatch(1));
CStdString replace = StringUtils::Format("&#x%s;", szReplace.c_str());
string.replace(string.begin()+pos-2, string.begin()+pos+4, replace);
}
CRegExp reg2;
reg2.RegComp("\\\\x([0-9]{2})([^\\\\]+;)");
while (reg2.RegFind(string.c_str()) > -1)
{
int pos1 = reg2.GetSubStart(1);
int pos2 = reg2.GetSubStart(2);
std::string szHexValue(reg2.GetMatch(1));
CStdString replace = StringUtils::Format("%c", strtol(szHexValue.c_str(), NULL, 16));
string.replace(string.begin()+pos1-2, string.begin()+pos2+reg2.GetSubLength(2), replace);
}
StringUtils::Replace(string, "\\\"","\"");
}
void CScraperParser::ReplaceBuffers(CStdString& strDest)
{
// insert buffers
size_t iIndex;
for (int i=MAX_SCRAPER_BUFFERS-1; i>=0; i--)
{
iIndex = 0;
CStdString temp = StringUtils::Format("$$%i",i+1);
while ((iIndex = strDest.find(temp,iIndex)) != CStdString::npos) // COPIED FROM CStdString WITH THE ADDITION OF $ ESCAPING
{
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iIndex+temp.size(),m_param[i]);
iIndex += m_param[i].length();
}
}
// insert settings
iIndex = 0;
while ((iIndex = strDest.find("$INFO[", iIndex)) != CStdString::npos)
{
size_t iEnd = strDest.find("]", iIndex);
CStdString strInfo = strDest.substr(iIndex+6, iEnd - iIndex - 6);
CStdString strReplace;
if (m_scraper)
strReplace = m_scraper->GetSetting(strInfo);
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iEnd+1,strReplace);
iIndex += strReplace.length();
}
// insert localize strings
iIndex = 0;
while ((iIndex = strDest.find("$LOCALIZE[", iIndex)) != CStdString::npos)
{
size_t iEnd = strDest.find("]", iIndex);
CStdString strInfo = strDest.substr(iIndex+10, iEnd - iIndex - 10);
CStdString strReplace;
if (m_scraper)
strReplace = m_scraper->GetString(strtol(strInfo.c_str(),NULL,10));
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iEnd+1,strReplace);
iIndex += strReplace.length();
}
iIndex = 0;
while ((iIndex = strDest.find("\\n",iIndex)) != CStdString::npos)
strDest.replace(strDest.begin()+iIndex,strDest.begin()+iIndex+2,"\n");
}
bool DVDPlayerCodec::Init(const CStdString &strFile, unsigned int filecache)
{
// take precaution if Init()ialized earlier
if (m_bInited)
{
// keep things as is if Init() was done with known strFile
if (m_strFileName == strFile)
return true;
// got differing filename, so cleanup before starting over
DeInit();
}
m_decoded = NULL;
m_nDecodedLen = 0;
CStdString strFileToOpen = strFile;
CURL urlFile(strFile);
if (urlFile.GetProtocol() == "shout" )
strFileToOpen.replace(0, 8, "http://");
m_pInputStream = CDVDFactoryInputStream::CreateInputStream(NULL, strFileToOpen, m_strContentType);
if (!m_pInputStream)
{
CLog::Log(LOGERROR, "%s: Error creating input stream for %s", __FUNCTION__, strFileToOpen.c_str());
return false;
}
if (!m_pInputStream->Open(strFileToOpen.c_str(), m_strContentType))
{
CLog::Log(LOGERROR, "%s: Error opening file %s", __FUNCTION__, strFileToOpen.c_str());
if (m_pInputStream)
delete m_pInputStream;
m_pInputStream = NULL;
return false;
}
m_pDemuxer = NULL;
try
{
m_pDemuxer = CDVDFactoryDemuxer::CreateDemuxer(m_pInputStream);
if (!m_pDemuxer)
{
delete m_pInputStream;
m_pInputStream = NULL;
CLog::Log(LOGERROR, "%s: Error creating demuxer", __FUNCTION__);
return false;
}
}
catch(...)
{
CLog::Log(LOGERROR, "%s: Exception thrown when opening demuxer", __FUNCTION__);
if (m_pDemuxer)
{
delete m_pDemuxer;
m_pDemuxer = NULL;
}
delete m_pInputStream;
m_pInputStream = NULL;
return false;
}
CDemuxStream* pStream = NULL;
m_nAudioStream = -1;
for (int i = 0; i < m_pDemuxer->GetNrOfStreams(); i++)
{
pStream = m_pDemuxer->GetStream(i);
if (pStream && pStream->type == STREAM_AUDIO)
{
m_nAudioStream = i;
break;
}
}
if (m_nAudioStream == -1)
{
CLog::Log(LOGERROR, "%s: Could not find audio stream", __FUNCTION__);
delete m_pDemuxer;
m_pDemuxer = NULL;
delete m_pInputStream;
m_pInputStream = NULL;
return false;
}
CDVDStreamInfo hint(*pStream, true);
m_pAudioCodec = CDVDFactoryCodec::CreateAudioCodec(hint);
if (!m_pAudioCodec)
{
CLog::Log(LOGERROR, "%s: Could not create audio codec", __FUNCTION__);
delete m_pDemuxer;
m_pDemuxer = NULL;
delete m_pInputStream;
m_pInputStream = NULL;
return false;
}
// Extract ReplayGain info
// tagLoaderTagLib.Load will try to determine tag type by file extension, so set fallback by contentType
CStdString strFallbackFileExtension = "";
if (m_strContentType.Equals("audio/aacp") || m_strContentType.Equals("audio/aacp" "audio/aac"))
strFallbackFileExtension = "m4a";
else if (m_strContentType.Equals("audio/x-ms-wma"))
strFallbackFileExtension = "wma";
else if (m_strContentType.Equals("audio/x-ape") || m_strContentType.Equals("audio/ape"))
strFallbackFileExtension = "ape";
CTagLoaderTagLib tagLoaderTagLib;
tagLoaderTagLib.Load(strFile, m_tag, strFallbackFileExtension);
// we have to decode initial data in order to get channels/samplerate
// for sanity - we read no more than 10 packets
int nErrors = 0;
for (int nPacket=0; nPacket < 10 && (m_Channels == 0 || m_SampleRate == 0); nPacket++)
{
BYTE dummy[256];
int nSize = 256;
if (ReadPCM(dummy, nSize, &nSize) == READ_ERROR)
++nErrors;
m_DataFormat = m_pAudioCodec->GetDataFormat();
m_BitsPerSample = CAEUtil::DataFormatToBits(m_DataFormat);
m_SampleRate = m_pAudioCodec->GetSampleRate();
m_EncodedSampleRate = m_pAudioCodec->GetEncodedSampleRate();
m_Channels = m_pAudioCodec->GetChannels();
m_ChannelInfo = m_pAudioCodec->GetChannelMap();
m_BitsPerCodedSample = static_cast<CDemuxStreamAudio*>(pStream)->iBitsPerSample;
}
if (nErrors >= 10)
{
CLog::Log(LOGDEBUG, "%s: Could not decode data", __FUNCTION__);
return false;
}
// test if seeking is supported
if (Seek(1) != DVD_NOPTS_VALUE)
{
// rewind stream to beginning
Seek(0);
m_bCanSeek = true;
}
else
{
m_pInputStream->Seek(0, SEEK_SET);
m_pDemuxer->Reset();
m_bCanSeek = false;
}
if (m_Channels == 0) // no data - just guess and hope for the best
m_Channels = 2;
if (m_SampleRate == 0)
m_SampleRate = 44100;
m_TotalTime = m_pDemuxer->GetStreamLength();
m_Bitrate = m_pAudioCodec->GetBitRate();
if (!m_Bitrate && m_TotalTime)
{
m_Bitrate = (int)(((m_pInputStream->GetLength()*1000) / m_TotalTime) * 8);
}
m_pDemuxer->GetStreamCodecName(m_nAudioStream,m_CodecName);
m_strFileName = strFile;
m_bInited = true;
return true;
}
void CScraperParser::Clean(CStdString& strDirty)
{
size_t i = 0;
CStdString strBuffer;
while ((i = strDirty.find("!!!CLEAN!!!",i)) != std::string::npos)
{
size_t i2;
if ((i2 = strDirty.find("!!!CLEAN!!!",i+11)) != std::string::npos)
{
strBuffer = strDirty.substr(i+11,i2-i-11);
CStdString strConverted(strBuffer);
HTML::CHTMLUtil::RemoveTags(strConverted);
StringUtils::Trim(strConverted);
strDirty.replace(i, i2-i+11, strConverted);
i += strConverted.size();
}
else
break;
}
i=0;
while ((i = strDirty.find("!!!TRIM!!!",i)) != std::string::npos)
{
size_t i2;
if ((i2 = strDirty.find("!!!TRIM!!!",i+10)) != std::string::npos)
{
strBuffer = strDirty.substr(i+10,i2-i-10);
StringUtils::Trim(strBuffer);
strDirty.replace(i, i2-i+10, strBuffer);
i += strBuffer.size();
}
else
break;
}
i=0;
while ((i = strDirty.find("!!!FIXCHARS!!!",i)) != std::string::npos)
{
size_t i2;
if ((i2 = strDirty.find("!!!FIXCHARS!!!",i+14)) != std::string::npos)
{
strBuffer = strDirty.substr(i+14,i2-i-14);
CStdStringW wbuffer;
g_charsetConverter.toW(strBuffer,wbuffer,GetSearchStringEncoding());
CStdStringW wConverted;
HTML::CHTMLUtil::ConvertHTMLToW(wbuffer,wConverted);
g_charsetConverter.fromW(wConverted,strBuffer,GetSearchStringEncoding());
StringUtils::Trim(strBuffer);
ConvertJSON(strBuffer);
strDirty.replace(i, i2-i+14, strBuffer);
i += strBuffer.size();
}
else
break;
}
i=0;
while ((i=strDirty.find("!!!ENCODE!!!",i)) != std::string::npos)
{
size_t i2;
if ((i2 = strDirty.find("!!!ENCODE!!!",i+12)) != std::string::npos)
{
strBuffer = CURL::Encode(strDirty.substr(i + 12, i2 - i - 12));
strDirty.replace(i, i2-i+12, strBuffer);
i += strBuffer.size();
}
else
break;
}
}
bool CPlayListPLS::Load(const CStdString &strFile)
{
//read it from the file
CStdString strFileName(strFile);
m_strPlayListName = URIUtils::GetFileName(strFileName);
Clear();
bool bShoutCast = false;
if( StringUtils::StartsWithNoCase(strFileName, "shout://") )
{
strFileName.replace(0, 8, "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;
StringUtils::Trim(strLine);
if(strLine.Equals(START_PLAYLIST_MARKER))
break;
// if there is something else before playlist marker, this isn't a pls file
if(!strLine.empty())
return false;
}
bool bFailed = false;
while (file.ReadString(szLine, sizeof(szLine) ) )
{
strLine = szLine;
StringUtils::RemoveCRLF(strLine);
size_t iPosEqual = strLine.find("=");
if (iPosEqual != std::string::npos)
{
CStdString strLeft = strLine.substr(0, iPosEqual);
iPosEqual++;
CStdString strValue = strLine.substr(iPosEqual);
StringUtils::ToLower(strLeft);
StringUtils::TrimLeft(strLeft);
if (strLeft == "numberofentries")
{
m_vecItems.reserve(atoi(strValue.c_str()));
}
else if (StringUtils::StartsWith(strLeft, "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(0, 7, "shout://");
strValue = URIUtils::SubstitutePath(strValue);
CUtil::GetQualifiedFilename(m_strBasePath, strValue);
g_charsetConverter.unknownToUTF8(strValue);
m_vecItems[idx - 1]->SetPath(strValue);
}
else if (StringUtils::StartsWith(strLeft, "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 (StringUtils::StartsWith(strLeft, "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;
}