void CLevelLocals::Load (CFile &File)
{
Frame = File.Read<FrameNumber> ();
FullLevelName = File.ReadString ();
ServerLevelName = File.ReadString ();
NextMap = File.ReadString ();
ForceMap = File.ReadString ();
Intermission = File.Read<SIntermissionState> ();
sint32 Index = File.Read<sint32> ();
if (Index != -1)
SightClient = entity_cast<CPlayerEntity>(Game.Entities[Index].Entity);
Secrets = File.Read<SGoalList> ();
Goals = File.Read<SGoalList> ();
Monsters = File.Read<SMonsterCount> ();
PowerCubeCount = File.Read<uint8> ();
Inhibit = File.Read<uint32> ();
EntityNumber = File.Read<uint32> ();
#if ROGUE_FEATURES
DisguiseViolationFrametime = File.Read<FrameNumber> ();
Index = File.Read<sint32> ();
if (Index != -1)
DisguiseViolator = Game.Entities[Index].Entity;
#endif
Entities.Load (File);
};
bool CAddonCallbacksAddon::ReadFileString(const void* addonData, void* file, char *szLine, int iLineLength)
{
CAddonInterfaces* helper = (CAddonInterfaces*) addonData;
if (!helper)
return false;
CFile* cfile = (CFile*)file;
if (!cfile)
return false;
return cfile->ReadString(szLine, iLineLength);
}
int CPatch::Parser(CString &pathfile)
{
CString str;
CFile PatchFile;
m_PathFile=pathfile;
if( ! PatchFile.Open(pathfile,CFile::modeRead) )
return -1;
#if 0
int i=0;
while(i<4)
{
PatchFile.ReadString(str);
if(i==1)
this->m_Author=str.Right( str.GetLength() - 6 );
if(i==2)
this->m_Date = str.Right( str.GetLength() - 6 );
if(i==3)
this->m_Subject = str.Right( str.GetLength() - 8 );
++i;
}
LONGLONG offset=PatchFile.GetPosition();
#endif
PatchFile.Read(m_Body.GetBuffer((UINT)PatchFile.GetLength()), (UINT)PatchFile.GetLength());
m_Body.ReleaseBuffer();
PatchFile.Close();
int start=0;
CStringA one;
one=m_Body.Tokenize("\n",start);
one=m_Body.Tokenize("\n",start);
if(one.GetLength()>6)
g_Git.StringAppend(&m_Author, (BYTE*)one.GetBuffer() + 6, CP_UTF8, one.GetLength() - 6);
one=m_Body.Tokenize("\n",start);
if(one.GetLength()>6)
g_Git.StringAppend(&m_Date, (BYTE*)one.GetBuffer() + 6, CP_UTF8, one.GetLength() - 6);
one=m_Body.Tokenize("\n",start);
if(one.GetLength()>9)
g_Git.StringAppend(&m_Subject, (BYTE*)one.GetBuffer() + 9, CP_UTF8, one.GetLength() - 9);
//one=m_Body.Tokenize("\n",start);
g_Git.StringAppend(&m_strBody, (BYTE*)m_Body.GetBuffer() + start + 1, CP_UTF8, m_Body.GetLength() - start - 1);
return 0;
}
bool CPlayListURL::Load(const CStdString& strFileName)
{
char szLine[4096];
CStdString strLine;
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;
StringUtils::RemoveCRLF(strLine);
if (strLine.Left(18) == "[InternetShortcut]")
{
if (file.ReadString(szLine,1024))
{
strLine = szLine;
StringUtils::RemoveCRLF(strLine);
if (strLine.Left(4) == "URL=")
{
CFileItemPtr newItem(new CFileItem(strLine.Mid(4),false));
Add(newItem);
}
}
}
}
file.Close();
return true;
}
std::vector<BLURAY_TITLE_INFO*> CBlurayDirectory::GetUserPlaylists()
{
std::string root = m_url.GetHostName();
std::string discInfPath = URIUtils::AddFileToFolder(root, "disc.inf");
std::vector<BLURAY_TITLE_INFO*> userTitles;
CFile file;
char buffer[1025];
if (file.Open(discInfPath))
{
CLog::Log(LOGDEBUG, "CBlurayDirectory::GetTitles - disc.inf found");
CRegExp pl(true);
if (!pl.RegComp("(\\d+)"))
{
file.Close();
return userTitles;
}
uint8_t maxLines = 100;
while ((maxLines > 0) && file.ReadString(buffer, 1024))
{
maxLines--;
if (StringUtils::StartsWithNoCase(buffer, "playlists"))
{
int pos = 0;
while ((pos = pl.RegFind(buffer, static_cast<unsigned int>(pos))) >= 0)
{
std::string playlist = pl.GetMatch(0);
uint32_t len = static_cast<uint32_t>(playlist.length());
if (len <= 5)
{
unsigned long int plNum = strtoul(playlist.c_str(), nullptr, 10);
BLURAY_TITLE_INFO* t = bd_get_playlist_info(m_bd, static_cast<uint32_t>(plNum), 0);
if (t)
userTitles.emplace_back(t);
}
if (static_cast<int64_t>(pos) + static_cast<int64_t>(len) > INT_MAX)
break;
else
pos += len;
}
}
}
file.Close();
}
return userTitles;
}
static bool
ScanUPnPShares(CFileItemList &items)
{
bool bMounted = false;
CStdString strDevicesFile = CStdString(UPNP_MNT) + "/devices";
bMounted = CUtil::IsMountpoint(UPNP_MNT) && CFile::Exists(strDevicesFile);
if(!bMounted)
{
CLog::Log(LOGERROR, "CUPnPAvDirectory:%s - UPnP mountpoint doesnt exist", __func__);
return false;
}
CFile fDevices;
char szDevice[1024] = {0};
if (!fDevices.Open(strDevicesFile))
{
CLog::Log(LOGERROR, "CUPnPAvDirectory:%s - Failed to open [%s]", __func__, strDevicesFile.c_str());
return false;
}
items.Clear();
while(fDevices.ReadString(szDevice, sizeof(szDevice)))
{
CFileItemPtr pItem(new CFileItem(szDevice));
CStdString strDevice = szDevice;
CUtil::URLEncode(strDevice);
pItem->m_bIsFolder = true;
pItem->m_strPath.Format("upnp://%s", strDevice);
items.Add(pItem);
}
fDevices.Close();
return items.Size() != 0;
}
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;
}
bool CEdl::ReadVideoReDo(const std::string& strMovie)
{
/*
* VideoReDo file is strange. Tags are XML like, but it isn't an XML file.
*
* http://www.videoredo.com/
*/
Clear();
std::string videoReDoFilename(URIUtils::ReplaceExtension(strMovie, ".Vprj"));
if (!CFile::Exists(videoReDoFilename))
return false;
CFile videoReDoFile;
if (!videoReDoFile.Open(videoReDoFilename))
{
CLog::Log(LOGERROR, "%s - Could not open VideoReDo file: %s", __FUNCTION__, videoReDoFilename.c_str());
return false;
}
char szBuffer[1024];
if (videoReDoFile.ReadString(szBuffer, 1023)
&& strncmp(szBuffer, VIDEOREDO_HEADER, strlen(VIDEOREDO_HEADER)) != 0)
{
CLog::Log(LOGERROR, "%s - Invalid VideoReDo file: %s. Error reading line 1 - expected %s. Only version 2 files are supported.",
__FUNCTION__, videoReDoFilename.c_str(), VIDEOREDO_HEADER);
videoReDoFile.Close();
return false;
}
int iLine = 1;
bool bValid = true;
while (bValid && videoReDoFile.ReadString(szBuffer, 1023))
{
iLine++;
if (strncmp(szBuffer, VIDEOREDO_TAG_CUT, strlen(VIDEOREDO_TAG_CUT)) == 0) // Found the <Cut> tag
{
/*
* double is used as 32 bit float would overflow.
*/
double dStart, dEnd;
if (sscanf(szBuffer + strlen(VIDEOREDO_TAG_CUT), "%lf:%lf", &dStart, &dEnd) == 2)
{
/*
* Times need adjusting by 1/10,000 to get ms.
*/
Cut cut;
cut.start = (int64_t)(dStart / 10000);
cut.end = (int64_t)(dEnd / 10000);
cut.action = CUT;
bValid = AddCut(cut);
}
else
bValid = false;
}
else if (strncmp(szBuffer, VIDEOREDO_TAG_SCENE, strlen(VIDEOREDO_TAG_SCENE)) == 0) // Found the <SceneMarker > tag
{
int iScene;
double dSceneMarker;
if (sscanf(szBuffer + strlen(VIDEOREDO_TAG_SCENE), " %i>%lf", &iScene, &dSceneMarker) == 2)
bValid = AddSceneMarker((int64_t)(dSceneMarker / 10000)); // Times need adjusting by 1/10,000 to get ms.
else
bValid = false;
}
/*
* Ignore any other tags.
*/
}
videoReDoFile.Close();
if (!bValid)
{
CLog::Log(LOGERROR, "%s - Invalid VideoReDo file: %s. Error in line %i. Clearing any valid cuts or scenes found.",
__FUNCTION__, videoReDoFilename.c_str(), iLine);
Clear();
return false;
}
else if (HasCut() || HasSceneMarker())
{
CLog::Log(LOGDEBUG, "%s - Read %" PRIuS" cuts and %" PRIuS" scene markers in VideoReDo file: %s", __FUNCTION__,
m_vecCuts.size(), m_vecSceneMarkers.size(), videoReDoFilename.c_str());
return true;
}
else
{
CLog::Log(LOGDEBUG, "%s - No cuts or scene markers found in VideoReDo file: %s", __FUNCTION__,
videoReDoFilename.c_str());
return false;
}
}
bool CEdl::ReadComskip(const std::string& strMovie, const float fFramesPerSecond)
{
Clear();
std::string comskipFilename(URIUtils::ReplaceExtension(strMovie, ".txt"));
if (!CFile::Exists(comskipFilename))
return false;
CFile comskipFile;
if (!comskipFile.Open(comskipFilename))
{
CLog::Log(LOGERROR, "%s - Could not open Comskip file: %s", __FUNCTION__, comskipFilename.c_str());
return false;
}
char szBuffer[1024];
if (comskipFile.ReadString(szBuffer, 1023)
&& strncmp(szBuffer, COMSKIP_HEADER, strlen(COMSKIP_HEADER)) != 0) // Line 1.
{
CLog::Log(LOGERROR, "%s - Invalid Comskip file: %s. Error reading line 1 - expected '%s' at start.",
__FUNCTION__, comskipFilename.c_str(), COMSKIP_HEADER);
comskipFile.Close();
return false;
}
int iFrames;
float fFrameRate;
if (sscanf(szBuffer, "FILE PROCESSING COMPLETE %i FRAMES AT %f", &iFrames, &fFrameRate) != 2)
{
/*
* Not all generated Comskip files have the frame rate information.
*/
fFrameRate = fFramesPerSecond;
CLog::Log(LOGWARNING, "%s - Frame rate not in Comskip file. Using detected frames per second: %.3f",
__FUNCTION__, fFrameRate);
}
else
fFrameRate /= 100; // Reduce by factor of 100 to get fps.
(void)comskipFile.ReadString(szBuffer, 1023); // Line 2. Ignore "-------------"
bool bValid = true;
int iLine = 2;
while (bValid && comskipFile.ReadString(szBuffer, 1023)) // Line 3 and onwards.
{
iLine++;
double dStartFrame, dEndFrame;
if (sscanf(szBuffer, "%lf %lf", &dStartFrame, &dEndFrame) == 2)
{
Cut cut;
cut.start = (int64_t)(dStartFrame / fFrameRate * 1000);
cut.end = (int64_t)(dEndFrame / fFrameRate * 1000);
cut.action = COMM_BREAK;
bValid = AddCut(cut);
}
else
bValid = false;
}
comskipFile.Close();
if (!bValid)
{
CLog::Log(LOGERROR, "%s - Invalid Comskip file: %s. Error on line %i. Clearing any valid commercial breaks found.",
__FUNCTION__, comskipFilename.c_str(), iLine);
Clear();
return false;
}
else if (HasCut())
{
CLog::Log(LOGDEBUG, "%s - Read %" PRIuS" commercial breaks from Comskip file: %s", __FUNCTION__, m_vecCuts.size(),
comskipFilename.c_str());
return true;
}
else
{
CLog::Log(LOGDEBUG, "%s - No commercial breaks found in Comskip file: %s", __FUNCTION__, comskipFilename.c_str());
return false;
}
}
bool CEdl::ReadEdl(const std::string& strMovie, const float fFramesPerSecond)
{
Clear();
std::string edlFilename(URIUtils::ReplaceExtension(strMovie, ".edl"));
if (!CFile::Exists(edlFilename))
return false;
CFile edlFile;
if (!edlFile.Open(edlFilename))
{
CLog::Log(LOGERROR, "%s - Could not open EDL file: %s", __FUNCTION__, edlFilename.c_str());
return false;
}
bool bError = false;
int iLine = 0;
std::string strBuffer;
strBuffer.resize(1024);
while (edlFile.ReadString(&strBuffer[0], 1024))
{
// Log any errors from previous run in the loop
if (bError)
CLog::Log(LOGWARNING, "%s - Error on line %i in EDL file: %s", __FUNCTION__, iLine, edlFilename.c_str());
bError = false;
iLine++;
char buffer1[513];
char buffer2[513];
int iAction;
int iFieldsRead = sscanf(strBuffer.c_str(), "%512s %512s %i", buffer1,
buffer2, &iAction);
if (iFieldsRead != 2 && iFieldsRead != 3) // Make sure we read the right number of fields
{
bError = true;
continue;
}
vector<string> strFields(2);
strFields[0] = buffer1;
strFields[1] = buffer2;
if (iFieldsRead == 2) // If only 2 fields read, then assume it's a scene marker.
{
iAction = atoi(strFields[1].c_str());
strFields[1] = strFields[0];
}
/*
* For each of the first two fields read, parse based on whether it is a time string
* (HH:MM:SS.sss), frame marker (#12345), or normal seconds string (123.45).
*/
int64_t iCutStartEnd[2];
for (int i = 0; i < 2; i++)
{
if (strFields[i].find(":") != std::string::npos) // HH:MM:SS.sss format
{
vector<string> fieldParts = StringUtils::Split(strFields[i], '.');
if (fieldParts.size() == 1) // No ms
{
iCutStartEnd[i] = StringUtils::TimeStringToSeconds(fieldParts[0]) * (int64_t)1000; // seconds to ms
}
else if (fieldParts.size() == 2) // Has ms. Everything after the dot (.) is ms
{
/*
* Have to pad or truncate the ms portion to 3 characters before converting to ms.
*/
if (fieldParts[1].length() == 1)
{
fieldParts[1] = fieldParts[1] + "00";
}
else if (fieldParts[1].length() == 2)
{
fieldParts[1] = fieldParts[1] + "0";
}
else if (fieldParts[1].length() > 3)
{
fieldParts[1] = fieldParts[1].substr(0, 3);
}
iCutStartEnd[i] = (int64_t)StringUtils::TimeStringToSeconds(fieldParts[0]) * 1000 + atoi(fieldParts[1].c_str()); // seconds to ms
}
else
{
bError = true;
continue;
}
}
else if (strFields[i][0] == '#') // #12345 format for frame number
{
iCutStartEnd[i] = (int64_t)(atol(strFields[i].substr(1).c_str()) / fFramesPerSecond * 1000); // frame number to ms
}
else // Plain old seconds in float format, e.g. 123.45
{
iCutStartEnd[i] = (int64_t)(atof(strFields[i].c_str()) * 1000); // seconds to ms
}
}
if (bError) // If there was an error in the for loop, ignore and continue with the next line
continue;
Cut cut;
cut.start = iCutStartEnd[0];
cut.end = iCutStartEnd[1];
switch (iAction)
{
case 0:
cut.action = CUT;
if (!AddCut(cut))
{
CLog::Log(LOGWARNING, "%s - Error adding cut from line %i in EDL file: %s", __FUNCTION__,
iLine, edlFilename.c_str());
continue;
}
break;
case 1:
cut.action = MUTE;
if (!AddCut(cut))
{
CLog::Log(LOGWARNING, "%s - Error adding mute from line %i in EDL file: %s", __FUNCTION__,
iLine, edlFilename.c_str());
continue;
}
break;
case 2:
if (!AddSceneMarker(cut.end))
{
CLog::Log(LOGWARNING, "%s - Error adding scene marker from line %i in EDL file: %s",
__FUNCTION__, iLine, edlFilename.c_str());
continue;
}
break;
case 3:
cut.action = COMM_BREAK;
if (!AddCut(cut))
{
CLog::Log(LOGWARNING, "%s - Error adding commercial break from line %i in EDL file: %s",
__FUNCTION__, iLine, edlFilename.c_str());
continue;
}
break;
default:
CLog::Log(LOGWARNING, "%s - Invalid action on line %i in EDL file: %s", __FUNCTION__, iLine,
edlFilename.c_str());
continue;
}
}
if (bError) // Log last line warning, if there was one, since while loop will have terminated.
CLog::Log(LOGWARNING, "%s - Error on line %i in EDL file: %s", __FUNCTION__, iLine, edlFilename.c_str());
edlFile.Close();
if (HasCut() || HasSceneMarker())
{
CLog::Log(LOGDEBUG, "%s - Read %" PRIuS" cuts and %" PRIuS" scene markers in EDL file: %s", __FUNCTION__,
m_vecCuts.size(), m_vecSceneMarkers.size(), edlFilename.c_str());
return true;
}
else
{
CLog::Log(LOGDEBUG, "%s - No cuts or scene markers found in EDL file: %s", __FUNCTION__,
edlFilename.c_str());
return false;
}
}
bool CPlayListM3U::Load(const std::string& strFileName)
{
char szLine[4096];
std::string strLine;
std::string strInfo;
long lDuration = 0;
int iStartOffset = 0;
int iEndOffset = 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, 4095))
{
strLine = szLine;
StringUtils::Trim(strLine);
if (StringUtils::StartsWith(strLine, M3U_INFO_MARKER))
{
// start of info
size_t iColon = strLine.find(":");
size_t iComma = strLine.find(",");
if (iColon != std::string::npos &&
iComma != std::string::npos &&
iComma > iColon)
{
// Read the info and duration
iColon++;
std::string strLength = strLine.substr(iColon, iComma - iColon);
lDuration = atoi(strLength.c_str());
iComma++;
strInfo = strLine.substr(iComma);
g_charsetConverter.unknownToUTF8(strInfo);
}
}
else if (StringUtils::StartsWith(strLine, M3U_OFFSET_MARKER))
{
size_t iColon = strLine.find(":");
size_t iComma = strLine.find(",");
if (iColon != std::string::npos &&
iComma != std::string::npos &&
iComma > iColon)
{
// Read the start and end offset
iColon++;
iStartOffset = atoi(strLine.substr(iColon, iComma - iColon).c_str());
iComma++;
iEndOffset = atoi(strLine.substr(iComma).c_str());
}
}
else if (strLine != M3U_START_MARKER &&
!StringUtils::StartsWith(strLine, M3U_ARTIST_MARKER) &&
!StringUtils::StartsWith(strLine, M3U_ALBUM_MARKER))
{
std::string 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
// We compare case-less in case user has input incorrect case of the current playlist
if (StringUtils::EqualsNoCase(URIUtils::GetFileName(strFileName), 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 (iStartOffset != 0 || iEndOffset != 0)
{
newItem->m_lStartOffset = iStartOffset;
newItem->m_lStartPartNumber = 1;
newItem->SetProperty("item_start", iStartOffset);
newItem->m_lEndOffset = iEndOffset;
// Prevent load message from file and override offset set here
newItem->GetMusicInfoTag()->SetLoaded();
newItem->GetMusicInfoTag()->SetTitle(strInfo);
if (iEndOffset)
lDuration = (iEndOffset - iStartOffset + 37) / 75;
}
if (newItem->IsVideo() && !newItem->HasVideoInfoTag()) // File is a video and needs a VideoInfoTag
newItem->GetVideoInfoTag()->Reset(); // Force VideoInfoTag creation
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;
iStartOffset = 0;
iEndOffset = 0;
}
}
}
file.Close();
return true;
}
std::string CPlayListM3U::GetBestBandwidthStream(const std::string &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];
std::string strLine;
size_t maxBandwidth = 0;
// open the file, and if it fails, return
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return strFileName;
}
// get protocol options if they were set, so we can restore them again at the end
CURL playlistUrl(strFileName);
// and set the fallback value
CURL subStreamUrl = CURL(strFileName);
// determine the base
CURL basePlaylistUrl(URIUtils::GetParentPath(strFileName));
basePlaylistUrl.SetOptions("");
basePlaylistUrl.SetProtocolOptions("");
std::string basePart = basePlaylistUrl.Get();
// 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;
StringUtils::Trim(strLine);
// skip the first line
if (strLine == M3U_START_MARKER)
continue;
else if (StringUtils::StartsWith(strLine, M3U_STREAM_MARKER))
{
// parse the line so we can pull out the bandwidth
std::map< std::string, std::string > params = ParseStreamLine(strLine);
std::map< std::string, std::string >::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;
StringUtils::Trim(strLine);
// 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))
subStreamUrl = CURL(strLine);
else
subStreamUrl = CURL(basePart + strLine);
}
}
}
}
// if any protocol options were set, restore them
subStreamUrl.SetProtocolOptions(playlistUrl.GetProtocolOptions());
return subStreamUrl.Get();
}
bool CEdl::ReadEdl(const CStdString& strMovie)
{
Clear();
CStdString edlFilename;
CUtil::ReplaceExtension(strMovie, ".edl", edlFilename);
if (!CFile::Exists(edlFilename))
return false;
CFile edlFile;
if (!edlFile.Open(edlFilename))
{
CLog::Log(LOGERROR, "%s - Could not open EDL file: %s", __FUNCTION__, edlFilename.c_str());
return false;
}
bool bValid = true;
char szBuffer[1024];
int iLine = 0;
while (bValid && edlFile.ReadString(szBuffer, 1023))
{
iLine++;
double dStart, dEnd;
int iAction;
if (sscanf(szBuffer, "%lf %lf %i", &dStart, &dEnd, &iAction) == 3)
{
if (dStart == dEnd) // Ignore zero length cuts in generated EDL files
continue;
Cut cut;
cut.start = (int)dStart * 1000; // ms to s
cut.end = (int)dEnd * 1000; // ms to s
switch (iAction)
{
case 0:
cut.action = CUT;
bValid = AddCut(cut);
break;
case 1:
cut.action = MUTE;
bValid = AddCut(cut);
break;
case 2:
bValid = AddSceneMarker(cut.end);
break;
case 3:
cut.action = COMM_BREAK;
bValid = AddCut(cut);
break;
default:
bValid = false;
continue;
}
}
else
bValid = false;
}
edlFile.Close();
if (!bValid)
{
CLog::Log(LOGERROR, "%s - Invalid EDL file: %s. Error in line %i. Clearing any valid cuts or scenes found.",
__FUNCTION__, edlFilename.c_str(), iLine);
Clear();
return false;
}
else if (HasCut() || HasSceneMarker())
{
CLog::Log(LOGDEBUG, "%s - Read %zu cuts and %zu scene markers in EDL file: %s", __FUNCTION__,
m_vecCuts.size(), m_vecSceneMarkers.size(), edlFilename.c_str());
return true;
}
else
{
CLog::Log(LOGDEBUG, "%s - No cuts or scene markers found in EDL file: %s", __FUNCTION__,
edlFilename.c_str());
return false;
}
}
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;
}
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;
}
