bool CPlayListB4S::LoadData(istream& stream)
{
CXBMCTinyXML xmlDoc;
stream >> xmlDoc;
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "Unable to parse B4S info Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement ) return false;
TiXmlElement* pPlayListElement = pRootElement->FirstChildElement("playlist");
if (!pPlayListElement ) return false;
m_strPlayListName = XMLUtils::GetAttribute(pPlayListElement, "label");
TiXmlElement* pEntryElement = pPlayListElement->FirstChildElement("entry");
if (!pEntryElement) return false;
while (pEntryElement)
{
std::string strFileName = XMLUtils::GetAttribute(pEntryElement, "Playstring");
size_t iColon = strFileName.find(":");
if (iColon != std::string::npos)
{
iColon++;
strFileName.erase(0, iColon);
}
if (strFileName.size())
{
TiXmlNode* pNodeInfo = pEntryElement->FirstChild("Name");
TiXmlNode* pNodeLength = pEntryElement->FirstChild("Length");
long lDuration = 0;
if (pNodeLength)
{
lDuration = atol(pNodeLength->FirstChild()->Value());
}
if (pNodeInfo)
{
std::string strInfo = pNodeInfo->FirstChild()->Value();
strFileName = URIUtils::SubstitutePath(strFileName);
CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
CFileItemPtr newItem(new CFileItem(strInfo));
newItem->SetPath(strFileName);
newItem->GetMusicInfoTag()->SetDuration(lDuration);
Add(newItem);
}
}
pEntryElement = pEntryElement->NextSiblingElement();
}
return true;
}
bool CPlayListWPL::LoadData(istream& stream)
{
CXBMCTinyXML xmlDoc;
stream >> xmlDoc;
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "Unable to parse B4S info Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement ) return false;
TiXmlElement* pHeadElement = pRootElement->FirstChildElement("head");
if (pHeadElement )
{
TiXmlElement* pTitelElement = pHeadElement->FirstChildElement("title");
if (pTitelElement )
m_strPlayListName = pTitelElement->Value();
}
TiXmlElement* pBodyElement = pRootElement->FirstChildElement("body");
if (!pBodyElement ) return false;
TiXmlElement* pSeqElement = pBodyElement->FirstChildElement("seq");
if (!pSeqElement ) return false;
TiXmlElement* pMediaElement = pSeqElement->FirstChildElement("media");
if (!pMediaElement) return false;
while (pMediaElement)
{
CStdString strFileName = pMediaElement->Attribute("src");
if (strFileName.size())
{
strFileName = URIUtils::SubstitutePath(strFileName);
CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
CStdString strDescription = URIUtils::GetFileName(strFileName);
CFileItemPtr newItem(new CFileItem(strDescription));
newItem->SetPath(strFileName);
Add(newItem);
}
pMediaElement = pMediaElement->NextSiblingElement();
}
return true;
}
bool CRSSDirectory::GetDirectory(const CURL& url, CFileItemList &items)
{
const std::string pathToUrl(url.Get());
std::string strPath(pathToUrl);
URIUtils::RemoveSlashAtEnd(strPath);
std::map<std::string,CDateTime>::iterator it;
items.SetPath(strPath);
CSingleLock lock(m_section);
if ((it=m_cache.find(strPath)) != m_cache.end())
{
if (it->second > CDateTime::GetCurrentDateTime() &&
items.Load())
return true;
m_cache.erase(it);
}
lock.Leave();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strPath))
{
CLog::Log(LOGERROR,"failed to load xml from <%s>. error: <%d>", strPath.c_str(), xmlDoc.ErrorId());
return false;
}
if (xmlDoc.Error())
{
CLog::Log(LOGERROR,"error parsing xml doc from <%s>. error: <%d>", strPath.c_str(), xmlDoc.ErrorId());
return false;
}
TiXmlElement* rssXmlNode = xmlDoc.RootElement();
if (!rssXmlNode)
return false;
TiXmlHandle docHandle( &xmlDoc );
TiXmlElement* channelXmlNode = docHandle.FirstChild( "rss" ).FirstChild( "channel" ).Element();
if (channelXmlNode)
ParseItem(&items, channelXmlNode, pathToUrl);
else
return false;
TiXmlElement* child = NULL;
for (child = channelXmlNode->FirstChildElement("item"); child; child = child->NextSiblingElement())
{
// Create new item,
CFileItemPtr item(new CFileItem());
ParseItem(item.get(), child, pathToUrl);
item->SetProperty("isrss", "1");
// Use channel image if item doesn't have one
if (!item->HasArt("thumb") && items.HasArt("thumb"))
item->SetArt("thumb", items.GetArt("thumb"));
if (!item->GetPath().empty())
items.Add(item);
}
items.AddSortMethod(SortByNone , 231, LABEL_MASKS("%L", "%D", "%L", "")); // FileName, Duration | Foldername, empty
items.AddSortMethod(SortByLabel , 551, LABEL_MASKS("%L", "%D", "%L", "")); // FileName, Duration | Foldername, empty
items.AddSortMethod(SortBySize , 553, LABEL_MASKS("%L", "%I", "%L", "%I")); // FileName, Size | Foldername, Size
items.AddSortMethod(SortByDate , 552, LABEL_MASKS("%L", "%J", "%L", "%J")); // FileName, Date | Foldername, Date
CDateTime time = CDateTime::GetCurrentDateTime();
int mins = 60;
TiXmlElement* ttl = docHandle.FirstChild("rss").FirstChild("ttl").Element();
if (ttl)
mins = strtol(ttl->FirstChild()->Value(),NULL,10);
time += CDateTimeSpan(0,0,mins,0);
items.SetPath(strPath);
items.Save();
CSingleLock lock2(m_section);
m_cache.insert(make_pair(strPath,time));
return true;
}
bool CPlayListASX::LoadData(istream& stream)
{
CLog::Log(LOGNOTICE, "Parsing ASX");
if(stream.peek() == '[')
{
return LoadAsxIniInfo(stream);
}
else
{
CXBMCTinyXML xmlDoc;
stream >> xmlDoc;
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "Unable to parse ASX info Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
// lowercase every element
TiXmlNode *pNode = pRootElement;
TiXmlNode *pChild = NULL;
CStdString value;
value = pNode->Value();
value.ToLower();
pNode->SetValue(value);
while(pNode)
{
pChild = pNode->IterateChildren(pChild);
if(pChild)
{
if (pChild->Type() == TiXmlNode::TINYXML_ELEMENT)
{
value = pChild->Value();
value.ToLower();
pChild->SetValue(value);
TiXmlAttribute* pAttr = pChild->ToElement()->FirstAttribute();
while(pAttr)
{
value = pAttr->Name();
value.ToLower();
pAttr->SetName(value);
pAttr = pAttr->Next();
}
}
pNode = pChild;
pChild = NULL;
continue;
}
pChild = pNode;
pNode = pNode->Parent();
}
CStdString roottitle = "";
TiXmlElement *pElement = pRootElement->FirstChildElement();
while (pElement)
{
value = pElement->Value();
if (value == "title")
{
roottitle = pElement->GetText();
}
else if (value == "entry")
{
CStdString title(roottitle);
TiXmlElement *pRef = pElement->FirstChildElement("ref");
TiXmlElement *pTitle = pElement->FirstChildElement("title");
if(pTitle)
title = pTitle->GetText();
while (pRef)
{ // multiple references may apear for one entry
// duration may exist on this level too
value = pRef->Attribute("href");
if (value != "")
{
if(title.IsEmpty())
title = value;
CLog::Log(LOGINFO, "Adding element %s, %s", title.c_str(), value.c_str());
CFileItemPtr newItem(new CFileItem(title));
newItem->SetPath(value);
Add(newItem);
}
pRef = pRef->NextSiblingElement("ref");
}
}
else if (value == "entryref")
{
value = pElement->Attribute("href");
if (value != "")
{ // found an entryref, let's try loading that url
auto_ptr<CPlayList> playlist(CPlayListFactory::Create(value));
if (NULL != playlist.get())
if (playlist->Load(value))
Add(*playlist);
}
}
pElement = pElement->NextSiblingElement();
}
}
return true;
}
bool CEdl::ReadBeyondTV(const std::string& strMovie)
{
Clear();
std::string beyondTVFilename(URIUtils::ReplaceExtension(strMovie, URIUtils::GetExtension(strMovie) + ".chapters.xml"));
if (!CFile::Exists(beyondTVFilename))
return false;
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(beyondTVFilename))
{
CLog::Log(LOGERROR, "%s - Could not load Beyond TV file: %s. %s", __FUNCTION__, beyondTVFilename.c_str(),
xmlDoc.ErrorDesc());
return false;
}
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "%s - Could not parse Beyond TV file: %s. %s", __FUNCTION__, beyondTVFilename.c_str(),
xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRoot = xmlDoc.RootElement();
if (!pRoot || strcmp(pRoot->Value(), "cutlist"))
{
CLog::Log(LOGERROR, "%s - Invalid Beyond TV file: %s. Expected root node to be <cutlist>", __FUNCTION__,
beyondTVFilename.c_str());
return false;
}
bool bValid = true;
TiXmlElement *pRegion = pRoot->FirstChildElement("Region");
while (bValid && pRegion)
{
TiXmlElement *pStart = pRegion->FirstChildElement("start");
TiXmlElement *pEnd = pRegion->FirstChildElement("end");
if (pStart && pEnd && pStart->FirstChild() && pEnd->FirstChild())
{
/*
* Need to divide the start and end times by a factor of 10,000 to get msec.
* E.g. <start comment="00:02:44.9980867">1649980867</start>
*
* Use atof so doesn't overflow 32 bit float or integer / long.
* E.g. <end comment="0:26:49.0000009">16090090000</end>
*
* Don't use atoll even though it is more correct as it isn't natively supported by
* Visual Studio.
*
* atof() returns 0 if there were any problems and will subsequently be rejected in AddCut().
*/
Cut cut;
cut.start = (int64_t)(atof(pStart->FirstChild()->Value()) / 10000);
cut.end = (int64_t)(atof(pEnd->FirstChild()->Value()) / 10000);
cut.action = COMM_BREAK;
bValid = AddCut(cut);
}
else
bValid = false;
pRegion = pRegion->NextSiblingElement("Region");
}
if (!bValid)
{
CLog::Log(LOGERROR, "%s - Invalid Beyond TV file: %s. Clearing any valid commercial breaks found.", __FUNCTION__,
beyondTVFilename.c_str());
Clear();
return false;
}
else if (HasCut())
{
CLog::Log(LOGDEBUG, "%s - Read %" PRIuS" commercial breaks from Beyond TV file: %s", __FUNCTION__, m_vecCuts.size(),
beyondTVFilename.c_str());
return true;
}
else
{
CLog::Log(LOGDEBUG, "%s - No commercial breaks found in Beyond TV file: %s", __FUNCTION__,
beyondTVFilename.c_str());
return false;
}
}
bool CLastFmManager::RequestRadioTracks()
{
unsigned int start = XbmcThreads::SystemClockMillis();
CStdString url;
CStdString html;
url.Format("http://" + m_RadioBaseUrl + m_RadioBasePath + "/xspf.php?sk=%s&discovery=0&desktop=", m_RadioSession);
{
CCurlFile http;
if (!http.Get(url, html))
{
m_RadioSession.empty();
CLog::Log(LOGERROR, "LastFmManager: Connect to Last.fm to request tracks failed.");
return false;
}
}
//CLog::Log(LOGDEBUG, "RequestRadioTracks: %s", html.c_str());
//parse playlist
CXBMCTinyXML xmlDoc;
xmlDoc.Parse(html);
if (xmlDoc.Error())
{
m_RadioSession.empty();
CLog::Log(LOGERROR, "LastFmManager: Unable to parse tracklist Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement )
{
CLog::Log(LOGWARNING, "LastFmManager: No more tracks received");
m_RadioSession.empty();
return false;
}
TiXmlElement* pBodyElement = pRootElement->FirstChildElement("trackList");
if (!pBodyElement )
{
CLog::Log(LOGWARNING, "LastFmManager: No more tracks received, no tracklist");
m_RadioSession.empty();
return false;
}
TiXmlElement* pTrackElement = pBodyElement->FirstChildElement("track");
if (!pTrackElement)
{
CLog::Log(LOGWARNING, "LastFmManager: No more tracks received, empty tracklist");
m_RadioSession.empty();
return false;
}
while (pTrackElement)
{
CFileItemPtr newItem(new CFileItem);
TiXmlElement* pElement = pTrackElement->FirstChildElement("location");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
CStdString url = child->Value();
url.Replace("http:", "lastfm:");
newItem->SetPath(url);
}
}
pElement = pTrackElement->FirstChildElement("title");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
newItem->SetLabel(child->Value());
newItem->GetMusicInfoTag()->SetTitle(child->Value());
}
}
pElement = pTrackElement->FirstChildElement("creator");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
newItem->GetMusicInfoTag()->SetArtist(child->Value());
}
}
pElement = pTrackElement->FirstChildElement("album");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
newItem->GetMusicInfoTag()->SetAlbum(child->Value());
}
}
pElement = pTrackElement->FirstChildElement("duration");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
int iDuration = atoi(child->Value())/1000;
newItem->GetMusicInfoTag()->SetDuration(iDuration);
}
}
newItem->FillInDefaultIcon();
pElement = pTrackElement->FirstChildElement("image");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
CStdString coverUrl = child->Value();
if ((coverUrl != "") && (coverUrl.Find("noimage") == -1) && (coverUrl.Right(1) != "/"))
{
newItem->SetThumbnailImage(coverUrl);
}
}
}
//trackauth is needed for validating the track when scrobbling
pElement = pTrackElement->FirstChildElement("lastfm:trackauth");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
CStdString trackAuth = child->Value();
//abuse comment field for the track authcode
newItem->GetMusicInfoTag()->SetComment(trackAuth);
}
}
{
CSingleLock lock(m_lockCache);
m_RadioTrackQueue->Add(newItem);
}
pTrackElement = pTrackElement->NextSiblingElement();
}
//end parse
CSingleLock lock(m_lockCache);
int iNrCachedTracks = m_RadioTrackQueue->size();
CLog::Log(LOGDEBUG, "%s: Done (time: %i ms)", __FUNCTION__, (int)(XbmcThreads::SystemClockMillis() - start));
return iNrCachedTracks > 0;
}
//*********************************************************************************************
bool CRTVDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CURL url(strPath);
CStdString strRoot = strPath;
URIUtils::AddSlashAtEnd(strRoot);
// Host name is "*" so we try to discover all ReplayTVs. This requires some trickery but works.
if (url.GetHostName() == "*")
{
// Check to see whether the URL's path is blank or "Video"
if (url.GetFileName() == "" || url.GetFileName() == "Video")
{
int iOldSize=items.Size();
struct RTV * rtv = NULL;
int numRTV;
// Request that all ReplayTVs on the LAN identify themselves. Each ReplayTV
// is given 3000ms to respond to the request. rtv_discovery returns an array
// of structs containing the IP and friendly name of all ReplayTVs found on the LAN.
// For some reason, DVArchive doesn't respond to this request (probably only responds
// to requests from an IP address of a real ReplayTV).
numRTV = rtv_discovery(&rtv, 3000);
// Run through the array and add the ReplayTVs found as folders in XBMC.
// We must add the IP of each ReplayTV as if it is a file name at the end of a the
// auto-discover URL--e.g. rtv://*/192.168.1.100--because XBMC does not permit
// dyamically added shares and will not play from them. This little trickery is
// the best workaround I could come up with.
for (int i = 0; i < numRTV; i++)
{
CFileItemPtr pItem(new CFileItem(rtv[i].friendlyName));
// This will keep the /Video or / and allow one to set up an auto ReplayTV
// share of either type--simple file listing or ReplayGuide listing.
pItem->SetPath(strRoot + rtv[i].hostname);
pItem->m_bIsFolder = true;
pItem->SetLabelPreformated(true);
items.Add(pItem);
}
free(rtv);
return (items.Size()>iOldSize);
// Else the URL's path should be an IP address of the ReplayTV
}
else
{
CStdString strURL, strRTV;
int pos;
// Isolate the IP from the URL and replace the "*" with the real IP
// of the ReplayTV. E.g., rtv://*/Video/192.168.1.100/ becomes
// rtv://192.168.1.100/Video/ . This trickery makes things work.
strURL = strRoot.TrimRight('/');
pos = strURL.ReverseFind('/');
strRTV = strURL.Left(pos + 1);
strRTV.Replace("*", strURL.Mid(pos + 1));
CURL tmpURL(strRTV);
// Force the newly constructed share into the right variables to
// be further processed by the remainder of GetDirectory.
url = tmpURL;
strRoot = strRTV;
}
}
// Allow for ReplayTVs on ports other than 80
CStdString strHostAndPort;
strHostAndPort = url.GetHostName();
if (url.HasPort())
{
char buffer[10];
sprintf(buffer,"%i",url.GetPort());
strHostAndPort += ':';
strHostAndPort += buffer;
}
// No path given, list shows from ReplayGuide
if (url.GetFileName() == "")
{
unsigned char * data = NULL;
// Get the RTV guide data in XML format
rtv_get_guide_xml(&data, strHostAndPort.c_str());
// Begin parsing the XML data
CXBMCTinyXML xmlDoc;
xmlDoc.Parse( (const char *) data );
if ( xmlDoc.Error() )
{
free(data);
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement)
{
free(data);
return false;
}
const TiXmlNode *pChild = pRootElement->FirstChild();
while (pChild > 0)
{
CStdString strTagName = pChild->Value();
if ( !strcmpi(strTagName.c_str(), "ITEM") )
{
const TiXmlNode *nameNode = pChild->FirstChild("DISPLAYNAME");
// const TiXmlNode *qualityNode = pChild->FirstChild("QUALITY");
const TiXmlNode *recordedNode = pChild->FirstChild("RECORDED");
const TiXmlNode *pathNode = pChild->FirstChild("PATH");
// const TiXmlNode *durationNode = pChild->FirstChild("DURATION");
const TiXmlNode *sizeNode = pChild->FirstChild("SIZE");
const TiXmlNode *atrbNode = pChild->FirstChild("ATTRIB");
SYSTEMTIME dtDateTime;
DWORD dwFileSize = 0;
memset(&dtDateTime, 0, sizeof(dtDateTime));
// DISPLAYNAME
const char* szName = NULL;
if (nameNode)
{
szName = nameNode->FirstChild()->Value() ;
}
else
{
// Something went wrong, the recording has no name
free(data);
return false;
}
// QUALITY
// const char* szQuality = NULL;
// if (qualityNode)
// {
// szQuality = qualityNode->FirstChild()->Value() ;
// }
// RECORDED
if (recordedNode)
{
CStdString strRecorded = recordedNode->FirstChild()->Value();
int iYear, iMonth, iDay;
iYear = atoi(strRecorded.Left(4).c_str());
iMonth = atoi(strRecorded.Mid(5, 2).c_str());
iDay = atoi(strRecorded.Mid(8, 2).c_str());
dtDateTime.wYear = iYear;
dtDateTime.wMonth = iMonth;
dtDateTime.wDay = iDay;
int iHour, iMin, iSec;
iHour = atoi(strRecorded.Mid(11, 2).c_str());
iMin = atoi(strRecorded.Mid(14, 2).c_str());
iSec = atoi(strRecorded.Mid(17, 2).c_str());
dtDateTime.wHour = iHour;
dtDateTime.wMinute = iMin;
dtDateTime.wSecond = iSec;
}
// PATH
const char* szPath = NULL;
if (pathNode)
{
szPath = pathNode->FirstChild()->Value() ;
}
else
{
// Something went wrong, the recording has no filename
free(data);
return false;
}
// DURATION
// const char* szDuration = NULL;
// if (durationNode)
// {
// szDuration = durationNode->FirstChild()->Value() ;
// }
// SIZE
// NOTE: Size here is actually just duration in minutes because
// filesize is not reported by the stripped down GuideParser I use
if (sizeNode)
{
dwFileSize = atol( sizeNode->FirstChild()->Value() );
}
// ATTRIB
// NOTE: Not currently reported in the XML guide data, nor is it particularly
// needed unless someone wants to add the ability to sub-divide the recordings
// into categories, as on a real RTV.
int attrib = 0;
if (atrbNode)
{
attrib = atoi( atrbNode->FirstChild()->Value() );
}
bool bIsFolder(false);
if (attrib & FILE_ATTRIBUTE_DIRECTORY)
bIsFolder = true;
CFileItemPtr pItem(new CFileItem(szName));
pItem->m_dateTime=dtDateTime;
pItem->SetPath(strRoot + szPath);
// Hack to show duration of show in minutes as KB in XMBC because
// it doesn't currently permit showing duration in minutes.
// E.g., a 30 minute show will show as 29.3 KB in XBMC.
pItem->m_dwSize = dwFileSize * 1000;
pItem->m_bIsFolder = bIsFolder;
pItem->SetLabelPreformated(true);
items.Add(pItem);
}
pChild = pChild->NextSibling();
}
free(data);
// Path given (usually Video), list filenames only
}
else
{
unsigned char * data;
char * p, * q;
unsigned long status;
// Return a listing of all files in the given path
status = rtv_list_files(&data, strHostAndPort.c_str(), url.GetFileName().c_str());
if (status == 0)
{
return false;
}
// Loop through the file list using pointers p and q, where p will point to the current
// filename and q will point to the next filename
p = (char *) data;
while (p)
{
// Look for the end of the current line of the file listing
q = strchr(p, '\n');
// If found, replace the newline character with the NULL terminator
if (q)
{
*q = '\0';
// Increment q so that it points to the next filename
q++;
// *p should be the current null-terminated filename in the list
if (*p)
{
// Only display MPEG files in XBMC (but not circular.mpg, as that is the RTV
// video buffer and XBMC may cause problems if it tries to play it)
if (strstr(p, ".mpg") && !strstr(p, "circular"))
{
CFileItemPtr pItem(new CFileItem(p));
pItem->SetPath(strRoot + p);
pItem->m_bIsFolder = false;
// The list returned by the RTV doesn't include file sizes, unfortunately
//pItem->m_dwSize = atol(szSize);
pItem->SetLabelPreformated(true);
items.Add(pItem);
}
}
}
// Point p to the next filename in the list and loop
p = q;
}
free(data);
}
return true;
}
bool CDVDStateSerializer::XMLToDVDState( dvd_state_t *state, const std::string &xmlstate )
{
CXBMCTinyXML xmlDoc;
xmlDoc.Parse(xmlstate.c_str());
if( xmlDoc.Error() )
return false;
TiXmlHandle hRoot( xmlDoc.RootElement() );
if( strcmp( hRoot.Element()->Value(), "navstate" ) != 0 ) return false;
TiXmlElement *element = NULL;
TiXmlText *text = NULL;
int index = 0;
element = hRoot.FirstChildElement("registers").FirstChildElement("sprm").Element();
while( element )
{
element->Attribute("index", &index);
text = TiXmlHandle( element ).FirstChildElement("value").FirstChild().Text();
if( text && index >= 0 && index < 24 )
sscanf(text->Value(), "0x%hx", &state->registers.SPRM[index]);
element = element->NextSiblingElement("sprm");
}
element = hRoot.FirstChildElement("registers").FirstChildElement("gprm").Element();
while( element )
{
element->Attribute("index", &index);
if( index >= 0 && index < 16 )
{
text = TiXmlHandle( element ).FirstChildElement("value").FirstChild().Text();
if( text )
sscanf(text->Value(), "0x%hx", &state->registers.GPRM[index]);
text = TiXmlHandle( element ).FirstChildElement("mode").FirstChild().Text();
if( text )
sscanf(text->Value(), "0x%c", &state->registers.GPRM_mode[index]);
text = TiXmlHandle( element ).FirstChildElement("time").FirstChildElement("tv_sec").FirstChild().Text();
if( text )
sscanf(text->Value(), "%ld", &state->registers.GPRM_time[index].tv_sec);
text = TiXmlHandle( element ).FirstChildElement("time").FirstChildElement("tv_usec").FirstChild().Text();
if( text )
sscanf(text->Value(), "%ld", (long int*)&state->registers.GPRM_time[index].tv_usec);
}
element = element->NextSiblingElement("gprm");
}
if( (text = hRoot.FirstChildElement("domain").FirstChild().Text()) )
sscanf(text->Value(), "%d", (int*) &state->domain);
if( (text = hRoot.FirstChildElement("vtsn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->vtsN);
if( (text = hRoot.FirstChildElement("pgcn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->pgcN);
if( (text = hRoot.FirstChildElement("pgn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->pgN);
if( (text = hRoot.FirstChildElement("celln").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->cellN);
if( (text = hRoot.FirstChildElement("cell_restart").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->cell_restart);
if( (text = hRoot.FirstChildElement("blockn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->blockN);
{ TiXmlHandle hrsm = hRoot.FirstChildElement("rsm");
if( (text = hrsm.FirstChildElement("vtsn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_vtsN);
if( (text = hrsm.FirstChildElement("blockn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_blockN);
if( (text = hrsm.FirstChildElement("pgcn").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_pgcN);
if( (text = hrsm.FirstChildElement("celln").FirstChild().Text()) )
sscanf(text->Value(), "%d", &state->rsm_cellN);
element = hrsm.FirstChildElement("registers").FirstChildElement("sprm").Element();
while( element )
{
element->Attribute("index", &index);
text = TiXmlHandle(element).FirstChildElement("value").FirstChild().Text();
if( text && index >= 0 && index < 5 )
sscanf(text->Value(), "0x%hx", &state->rsm_regs[index]);
element = element->NextSiblingElement("sprm");
}
}
return true;
}