bool CGUIPythonWindowXML::LoadXML(const CStdString &strPath, const CStdString &strLowerPath)
{
// load our window
XFILE::CFile file;
if (!file.Open(strPath) && !file.Open(CStdString(strPath).ToLower()) && !file.Open(strLowerPath))
{
// fail - can't load the file
CLog::Log(LOGERROR, "%s: Unable to load skin file %s", __FUNCTION__, strPath.c_str());
return false;
}
// load the strings in
unsigned int offset = LoadScriptStrings();
CStdString xml;
char *buffer = new char[(unsigned int)file.GetLength()+1];
if(buffer == NULL)
return false;
int size = file.Read(buffer, file.GetLength());
if (size > 0)
{
buffer[size] = 0;
xml = buffer;
if (offset)
{
// replace the occurences of SCRIPT### with offset+###
// not particularly efficient, but it works
int pos = xml.Find("SCRIPT");
while (pos != (int)CStdString::npos)
{
CStdString num = xml.Mid(pos + 6, 4);
int number = atol(num.c_str());
CStdString oldNumber, newNumber;
oldNumber.Format("SCRIPT%d", number);
newNumber.Format("%lu", offset + number);
xml.Replace(oldNumber, newNumber);
pos = xml.Find("SCRIPT", pos + 6);
}
}
}
delete[] buffer;
TiXmlDocument xmlDoc;
xmlDoc.Parse(xml.c_str());
if (xmlDoc.Error())
return false;
return Load(xmlDoc);
}
bool CJpegIO::Open(const CStdString &texturePath, unsigned int minx, unsigned int miny, bool read)
{
m_texturePath = texturePath;
unsigned int imgsize = 0;
XFILE::CFile file;
if (file.Open(m_texturePath.c_str(), 0))
{
imgsize = (unsigned int)file.GetLength();
m_inputBuff = new unsigned char[imgsize];
m_inputBuffSize = file.Read(m_inputBuff, imgsize);
file.Close();
if ((imgsize != m_inputBuffSize) || (m_inputBuffSize == 0))
return false;
}
else
return false;
if (!read)
return true;
if (Read(m_inputBuff, m_inputBuffSize, minx, miny))
return true;
return false;
}
HRESULT CD3DEffect::Open(D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID* ppData, UINT* pBytes)
{
XFILE::CFile includeFile;
std::string fileName("special://xbmc/system/shaders/");
fileName.append(pFileName);
if (!includeFile.Open(fileName))
{
CLog::Log(LOGERROR, "%s: Could not open 3DLUT file: %s", __FUNCTION__, fileName.c_str());
return E_FAIL;
}
int64_t length = includeFile.GetLength();
void *pData = malloc(length);
if (includeFile.Read(pData, length) != length)
{
free(pData);
return E_FAIL;
}
*ppData = pData;
*pBytes = length;
return S_OK;
}
//========================================================================
int CFileURLProtocol::Open(URLContext *h, const char *filename, int flags)
{
if (flags != URL_RDONLY)
{
CLog::Log(LOGDEBUG, "CFileURLProtocol::Open: Only read-only is supported");
return -EINVAL;
}
CStdString url = filename;
if (url.Left(strlen("xb-http://")).Equals("xb-http://"))
{
url = url.Right(url.size() - strlen("xb-"));
}
CLog::Log(LOGDEBUG, "CFileURLProtocol::Open filename2(%s)", url.c_str());
// open the file, always in read mode, calc bitrate
unsigned int cflags = READ_BITRATE;
XFILE::CFile *cfile = new XFILE::CFile();
if (CFileItem(url, false).IsInternetStream())
cflags |= READ_CACHED;
// open file in binary mode
if (!cfile->Open(url, cflags))
{
delete cfile;
return -EIO;
}
h->priv_data = (void *)cfile;
return 0;
}
TEST(TestFile, Write)
{
XFILE::CFile *file;
const char str[] = "TestFile.Write test string\n";
char buf[30];
memset(&buf, 0, sizeof(buf));
ASSERT_TRUE((file = XBMC_CREATETEMPFILE("")) != NULL);
file->Close();
ASSERT_TRUE(file->OpenForWrite(XBMC_TEMPFILEPATH(file), true));
EXPECT_EQ((int)sizeof(str), file->Write(str, sizeof(str)));
file->Flush();
EXPECT_EQ(0, file->GetPosition());
file->Close();
ASSERT_TRUE(file->Open(XBMC_TEMPFILEPATH(file)));
EXPECT_EQ(0, file->GetPosition());
EXPECT_EQ((int64_t)sizeof(str), file->Seek(0, SEEK_END));
EXPECT_EQ(0, file->Seek(0, SEEK_SET));
EXPECT_EQ((int64_t)sizeof(str), file->GetLength());
EXPECT_EQ(sizeof(str), file->Read(buf, sizeof(buf)));
file->Flush();
EXPECT_EQ((int64_t)sizeof(str), file->GetPosition());
EXPECT_TRUE(!memcmp(str, buf, sizeof(str)));
file->Close();
EXPECT_TRUE(XBMC_DELETETEMPFILE(file));
}
int CNfoFile::Load(const CStdString& strFile)
{
Close();
XFILE::CFile file;
if (file.Open(strFile))
{
m_size = (int)file.GetLength();
try
{
m_doc = new char[m_size+1];
m_headofdoc = m_doc;
}
catch (...)
{
CLog::Log(LOGERROR, "%s: Exception while creating file buffer",__FUNCTION__);
return 1;
}
if (!m_doc)
{
file.Close();
return 1;
}
file.Read(m_doc, m_size);
m_doc[m_size] = 0;
file.Close();
return 0;
}
return 1;
}
bool Gif::IsAnimated(const char* file)
{
if (!m_dll.IsLoaded())
return false;
if (m_isAnimated < 0)
{
m_filename = file;
m_isAnimated = 0;
GifFileType* gif = nullptr;
XFILE::CFile gifFile;
if (!gifFile.Open(file) || !Open(gif, &gifFile, ReadFromVfs))
return false;
if (gif)
{
if (Slurp(gif) && gif->ImageCount > 1)
m_isAnimated = 1;
Close(gif);
gifFile.Close();
}
}
return m_isAnimated > 0;
}
TEST_F(TestRegExpLog, DumpOvector)
{
CRegExp regex;
CStdString logfile, logstring;
char buf[100];
unsigned int bytesread;
XFILE::CFile file;
logfile = CSpecialProtocol::TranslatePath("special://temp/") + "xbmc.log";
EXPECT_TRUE(CLog::Init(CSpecialProtocol::TranslatePath("special://temp/")));
EXPECT_TRUE(XFILE::CFile::Exists(logfile));
EXPECT_TRUE(regex.RegComp("^(?<first>Test)\\s*(?<second>.*)\\."));
EXPECT_EQ(0, regex.RegFind("Test string."));
regex.DumpOvector(LOGDEBUG);
CLog::Close();
EXPECT_TRUE(file.Open(logfile));
while ((bytesread = file.Read(buf, sizeof(buf) - 1)) > 0)
{
buf[bytesread] = '\0';
logstring.append(buf);
}
file.Close();
EXPECT_FALSE(logstring.empty());
EXPECT_STREQ("\xEF\xBB\xBF", logstring.substr(0, 3).c_str());
EXPECT_TRUE(regex.RegComp(".*DEBUG: regexp ovector=\\{\\[0,12\\],\\[0,4\\],"
"\\[5,11\\]\\}.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(XFILE::CFile::Delete(logfile));
}
bool CScraperUrl::Get(const SUrlEntry& scrURL, string& strHTML, CHTTP& http)
{
CURL url(scrURL.m_url);
http.SetReferer(scrURL.m_spoof);
CStdString strCachePath;
if (!scrURL.m_cache.IsEmpty())
{
CUtil::AddFileToFolder(g_advancedSettings.m_cachePath,"scrapers\\"+scrURL.m_cache,strCachePath);
if (XFILE::CFile::Exists(strCachePath))
{
XFILE::CFile file;
file.Open(strCachePath);
char* temp = new char[(int)file.GetLength()];
file.Read(temp,file.GetLength());
strHTML.append(temp,temp+file.GetLength());
file.Close();
delete[] temp;
return true;
}
}
if (scrURL.m_post)
{
CStdString strOptions = url.GetOptions();
strOptions = strOptions.substr(1);
url.SetOptions("");
CStdString strUrl;
url.GetURL(strUrl);
if (!http.Post(strUrl, strOptions, strHTML))
return false;
}
else if (!http.Get(scrURL.m_url, strHTML))
return false;
if (scrURL.m_url.Find(".zip") > -1)
{
XFILE::CFileZip file;
CStdString strBuffer;
int iSize = file.UnpackFromMemory(strBuffer,strHTML);
if (iSize)
{
strHTML.clear();
strHTML.append(strBuffer.c_str(),strBuffer.data()+iSize);
}
}
if (!scrURL.m_cache.IsEmpty())
{
CStdString strCachePath;
CUtil::AddFileToFolder(g_advancedSettings.m_cachePath,"scrapers\\"+scrURL.m_cache,strCachePath);
XFILE::CFile file;
if (file.OpenForWrite(strCachePath,true,true))
file.Write(strHTML.data(),strHTML.size());
file.Close();
}
return true;
}
bool CKaraokeLyricsTextLRC::Load()
{
XFILE::CFile file;
// Clear the lyrics array
clearLyrics();
if ( !file.Open( m_lyricsFile ) )
return false;
unsigned int lyricSize = (unsigned int) file.GetLength();
if ( !lyricSize )
{
CLog::Log( LOGERROR, "LRC lyric loader: lyric file %s has zero length", m_lyricsFile.c_str() );
return false;
}
// Read the file into memory array
std::vector<char> lyricData( lyricSize );
file.Seek( 0, SEEK_SET );
// Read the whole file
if ( file.Read( &lyricData[0], lyricSize) != lyricSize )
return false; // disk error?
file.Close();
// Parse the correction value
int timing_correction = MathUtils::round_int( g_advancedSettings.m_karaokeSyncDelayLRC * 10 );
unsigned int offset = 0;
CStdString ext, songfilename = getSongFile();
URIUtils::GetExtension( songfilename, ext );
// Skip windoze UTF8 file prefix, if any, and reject UTF16 files
if ( lyricSize > 3 )
{
if ( (unsigned char)lyricData[0] == 0xFF && (unsigned char)lyricData[1] == 0xFE )
{
CLog::Log( LOGERROR, "LRC lyric loader: lyrics file is in UTF16 encoding, must be in UTF8" );
return false;
}
// UTF8 prefix added by some windoze apps
if ( (unsigned char)lyricData[0] == 0xEF && (unsigned char)lyricData[1] == 0xBB && (unsigned char)lyricData[2] == 0xBF )
offset = 3;
}
if (checkMultiTime(&lyricData[offset], lyricSize - offset))
return ParserMultiTime(&lyricData[offset], lyricSize - offset, timing_correction);
else
return ParserNormal(&lyricData[offset], lyricSize - offset, timing_correction);
}
bool CPFCManager::GetDefsFile(const CStdString& strPath, TiXmlDocument& xmlDocument) {
// CStdString strTemp = strPath;
//
// if (!URIUtils::IsURL(strTemp)) {
// CURL::Encode(strTemp);
// }
CURL urlPath(strPath);
CStdString strFile = urlPath.GetHostName();
URIUtils::CreateArchivePath(strFile, "pfc", strPath, DEFSFILE);
char* defFile;
CStdString strDoc;
XFILE::CFile file;
if (file.Open(strFile))
{
int size = (int) file.GetLength();
try
{
defFile = new char[size + 1];
}
catch (...)
{
CLog::Log(LOGERROR, "%s: Exception while creating file buffer", __FUNCTION__);
return false;
}
if (!defFile)
{
file.Close();
return false;
}
file.Read(defFile, size);
defFile[size] = 0;
strDoc = defFile;
file.Close();
free(defFile);
}
// Laureon: Convert the document to UTF8...
if (strDoc.Find("encoding=") == -1) g_charsetConverter.unknownToUTF8(strDoc);
xmlDocument.Parse(strDoc.c_str());
if (!xmlDocument.RootElement()) return false;
return true;
}
TEST_F(Testlog, Log)
{
std::string logfile, logstring;
char buf[100];
unsigned int bytesread;
XFILE::CFile file;
CRegExp regex;
std::string appName = CCompileInfo::GetAppName();
StringUtils::ToLower(appName);
logfile = CSpecialProtocol::TranslatePath("special://temp/") + appName + ".log";
EXPECT_TRUE(CLog::Init(CSpecialProtocol::TranslatePath("special://temp/").c_str()));
EXPECT_TRUE(XFILE::CFile::Exists(logfile));
CLog::Log(LOGDEBUG, "debug log message");
CLog::Log(LOGINFO, "info log message");
CLog::Log(LOGNOTICE, "notice log message");
CLog::Log(LOGWARNING, "warning log message");
CLog::Log(LOGERROR, "error log message");
CLog::Log(LOGSEVERE, "severe log message");
CLog::Log(LOGFATAL, "fatal log message");
CLog::Log(LOGNONE, "none type log message");
CLog::Close();
EXPECT_TRUE(file.Open(logfile));
while ((bytesread = file.Read(buf, sizeof(buf) - 1)) > 0)
{
buf[bytesread] = '\0';
logstring.append(buf);
}
file.Close();
EXPECT_FALSE(logstring.empty());
EXPECT_STREQ("\xEF\xBB\xBF", logstring.substr(0, 3).c_str());
EXPECT_TRUE(regex.RegComp(".*DEBUG: debug log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*INFO: info log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*NOTICE: notice log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*WARNING: warning log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*ERROR: error log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*SEVERE: severe log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*FATAL: fatal log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*NONE: none type log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(XFILE::CFile::Delete(logfile));
}
TEST_F(TestZipFile, Read)
{
XFILE::CFile file;
char buf[20];
memset(&buf, 0, sizeof(buf));
std::string reffile, strpathinzip;
CFileItemList itemlist;
reffile = XBMC_REF_FILE_PATH("xbmc/filesystem/test/reffile.txt.zip");
CURL zipUrl = URIUtils::CreateArchivePath("zip", CURL(reffile), "");
ASSERT_TRUE(XFILE::CDirectory::GetDirectory(zipUrl, itemlist, "",
XFILE::DIR_FLAG_NO_FILE_DIRS));
EXPECT_GT(itemlist.Size(), 0);
EXPECT_FALSE(itemlist[0]->GetPath().empty());
strpathinzip = itemlist[0]->GetPath();
ASSERT_TRUE(file.Open(strpathinzip));
EXPECT_EQ(0, file.GetPosition());
EXPECT_EQ(1616, file.GetLength());
EXPECT_EQ(sizeof(buf), static_cast<size_t>(file.Read(buf, sizeof(buf))));
file.Flush();
EXPECT_EQ(20, file.GetPosition());
EXPECT_TRUE(!memcmp("About\n-----\nXBMC is ", buf, sizeof(buf) - 1));
EXPECT_TRUE(file.ReadString(buf, sizeof(buf)));
EXPECT_EQ(39, file.GetPosition());
EXPECT_STREQ("an award-winning fr", buf);
EXPECT_EQ(100, file.Seek(100));
EXPECT_EQ(100, file.GetPosition());
EXPECT_EQ(sizeof(buf), static_cast<size_t>(file.Read(buf, sizeof(buf))));
file.Flush();
EXPECT_EQ(120, file.GetPosition());
EXPECT_TRUE(!memcmp("ent hub for digital ", buf, sizeof(buf) - 1));
EXPECT_EQ(220, file.Seek(100, SEEK_CUR));
EXPECT_EQ(220, file.GetPosition());
EXPECT_EQ(sizeof(buf), static_cast<size_t>(file.Read(buf, sizeof(buf))));
file.Flush();
EXPECT_EQ(240, file.GetPosition());
EXPECT_TRUE(!memcmp("rs, XBMC is a non-pr", buf, sizeof(buf) - 1));
EXPECT_EQ(1596, file.Seek(-(int64_t)sizeof(buf), SEEK_END));
EXPECT_EQ(1596, file.GetPosition());
EXPECT_EQ(sizeof(buf), static_cast<size_t>(file.Read(buf, sizeof(buf))));
file.Flush();
EXPECT_EQ(1616, file.GetPosition());
EXPECT_TRUE(!memcmp("multimedia jukebox.\n", buf, sizeof(buf) - 1));
EXPECT_EQ(-1, file.Seek(100, SEEK_CUR));
EXPECT_EQ(1616, file.GetPosition());
EXPECT_EQ(0, file.Seek(0, SEEK_SET));
EXPECT_EQ(sizeof(buf), static_cast<size_t>(file.Read(buf, sizeof(buf))));
file.Flush();
EXPECT_EQ(20, file.GetPosition());
EXPECT_TRUE(!memcmp("About\n-----\nXBMC is ", buf, sizeof(buf) - 1));
EXPECT_EQ(0, file.Seek(0, SEEK_SET));
EXPECT_EQ(-1, file.Seek(-100, SEEK_SET));
file.Close();
}
TEST(TestRarFile, Read)
{
XFILE::CFile file;
char buf[20];
memset(&buf, 0, sizeof(buf));
CStdString reffile, strrarpath, strpathinrar;
CFileItemList itemlist;
reffile = XBMC_REF_FILE_PATH("xbmc/filesystem/test/reffile.txt.rar");
URIUtils::CreateArchivePath(strrarpath, "rar", reffile, "");
ASSERT_TRUE(XFILE::CDirectory::GetDirectory(strrarpath, itemlist, "",
XFILE::DIR_FLAG_NO_FILE_DIRS));
strpathinrar = itemlist[0]->GetPath();
ASSERT_TRUE(file.Open(strpathinrar));
EXPECT_EQ(0, file.GetPosition());
EXPECT_EQ(1616, file.GetLength());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(20, file.GetPosition());
EXPECT_TRUE(!memcmp("About\n-----\nXBMC is ", buf, sizeof(buf) - 1));
EXPECT_TRUE(file.ReadString(buf, sizeof(buf)));
EXPECT_EQ(39, file.GetPosition());
EXPECT_STREQ("an award-winning fr", buf);
EXPECT_EQ(100, file.Seek(100));
EXPECT_EQ(100, file.GetPosition());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(120, file.GetPosition());
EXPECT_TRUE(!memcmp("ent hub for digital ", buf, sizeof(buf) - 1));
EXPECT_EQ(220, file.Seek(100, SEEK_CUR));
EXPECT_EQ(220, file.GetPosition());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(240, file.GetPosition());
EXPECT_TRUE(!memcmp("rs, XBMC is a non-pr", buf, sizeof(buf) - 1));
EXPECT_EQ(1596, file.Seek(-(int64_t)sizeof(buf), SEEK_END));
EXPECT_EQ(1596, file.GetPosition());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(1616, file.GetPosition());
EXPECT_TRUE(!memcmp("multimedia jukebox.\n", buf, sizeof(buf) - 1));
EXPECT_EQ(1716, file.Seek(100, SEEK_CUR));
EXPECT_EQ(1716, file.GetPosition());
EXPECT_EQ(0, file.Seek(0, SEEK_SET));
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(20, file.GetPosition());
EXPECT_TRUE(!memcmp("About\n-----\nXBMC is ", buf, sizeof(buf) - 1));
EXPECT_EQ(0, file.Seek(0, SEEK_SET));
EXPECT_EQ(-1, file.Seek(-100, SEEK_SET));
file.Close();
}
bool CFileCurl::ReadFile(const CStdString &fileName, CStdString &out)
{
XFILE::CFile file;
if (file.Open(fileName))
{
char buffer[16384];
unsigned int size_read;
while( (size_read = file.Read(buffer, sizeof(buffer)) ) > 0 )
out.append(buffer, size_read);
file.Close();
return true;
}
return false;
}
/* The tests for XFILE::CFileFactory are tested indirectly through
* XFILE::CFile. Since most parts of the VFS require some form of
* network connection, the settings and VFS URLs must be given as
* arguments in the main testsuite program.
*/
TEST_F(TestFileFactory, Read)
{
XFILE::CFile file;
std::string str;
unsigned int size, i;
unsigned char buf[16];
int64_t count = 0;
std::vector<std::string> urls =
CXBMCTestUtils::Instance().getTestFileFactoryReadUrls();
std::vector<std::string>::iterator it;
for (it = urls.begin(); it < urls.end(); ++it)
{
std::cout << "Testing URL: " << *it << std::endl;
ASSERT_TRUE(file.Open(*it));
std::cout << "file.GetLength(): " <<
testing::PrintToString(file.GetLength()) << std::endl;
std::cout << "file.Seek(file.GetLength() / 2, SEEK_CUR) return value: " <<
testing::PrintToString(file.Seek(file.GetLength() / 2, SEEK_CUR)) << std::endl;
std::cout << "file.Seek(0, SEEK_END) return value: " <<
testing::PrintToString(file.Seek(0, SEEK_END)) << std::endl;
std::cout << "file.Seek(0, SEEK_SET) return value: " <<
testing::PrintToString(file.Seek(0, SEEK_SET)) << std::endl;
std::cout << "File contents:" << std::endl;
while ((size = file.Read(buf, sizeof(buf))) > 0)
{
str = StringUtils::Format(" %08llX", count);
std::cout << str << " ";
count += size;
for (i = 0; i < size; i++)
{
str = StringUtils::Format("%02X ", buf[i]);
std::cout << str;
}
while (i++ < sizeof(buf))
std::cout << " ";
std::cout << " [";
for (i = 0; i < size; i++)
{
if (buf[i] >= ' ' && buf[i] <= '~')
std::cout << buf[i];
else
std::cout << ".";
}
std::cout << "]" << std::endl;
}
file.Close();
}
}
void CHTTPFileHandler::SetFile(const std::string& file, int responseStatus)
{
m_url = file;
m_response.status = responseStatus;
if (m_url.empty())
return;
// translate the response status into the response type
if (m_response.status == MHD_HTTP_OK)
m_response.type = HTTPFileDownload;
else if (m_response.status == MHD_HTTP_FOUND)
m_response.type = HTTPRedirect;
else
m_response.type = HTTPError;
// try to determine some additional information if the file can be downloaded
if (m_response.type == HTTPFileDownload)
{
// determine the content type
std::string ext = URIUtils::GetExtension(m_url);
StringUtils::ToLower(ext);
m_response.contentType = CMime::GetMimeType(ext);
// determine the last modified date
XFILE::CFile fileObj;
if (!fileObj.Open(m_url, XFILE::READ_NO_CACHE))
{
m_response.type = HTTPError;
m_response.status = MHD_HTTP_INTERNAL_SERVER_ERROR;
}
else
{
struct __stat64 statBuffer;
if (fileObj.Stat(&statBuffer) == 0)
SetLastModifiedDate(&statBuffer);
}
}
// disable ranges and caching if the file can't be downloaded
if (m_response.type != HTTPFileDownload)
{
m_canHandleRanges = false;
m_canBeCached = false;
}
// disable caching if the last modified date couldn't be read
if (!m_lastModified.IsValid())
m_canBeCached = false;
}
TEST(TestFile, Read)
{
XFILE::CFile file;
char buf[20];
memset(&buf, 0, sizeof(buf));
ASSERT_TRUE(file.Open(
XBMC_REF_FILE_PATH("/xbmc/filesystem/test/reffile.txt")));
EXPECT_EQ(0, file.GetPosition());
EXPECT_EQ(1616, file.GetLength());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(20, file.GetPosition());
EXPECT_TRUE(!memcmp("About\n-----\nXBMC is ", buf, sizeof(buf) - 1));
EXPECT_TRUE(file.ReadString(buf, sizeof(buf)));
EXPECT_EQ(39, file.GetPosition());
EXPECT_STREQ("an award-winning fr", buf);
EXPECT_EQ(100, file.Seek(100));
EXPECT_EQ(100, file.GetPosition());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(120, file.GetPosition());
EXPECT_TRUE(!memcmp("ent hub for digital ", buf, sizeof(buf) - 1));
EXPECT_EQ(220, file.Seek(100, SEEK_CUR));
EXPECT_EQ(220, file.GetPosition());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(240, file.GetPosition());
EXPECT_TRUE(!memcmp("rs, XBMC is a non-pr", buf, sizeof(buf) - 1));
EXPECT_EQ(1596, file.Seek(-sizeof(buf), SEEK_END));
EXPECT_EQ(1596, file.GetPosition());
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(1616, file.GetPosition());
EXPECT_TRUE(!memcmp("multimedia jukebox.\n", buf, sizeof(buf) - 1));
EXPECT_EQ(1716, file.Seek(100, SEEK_CUR));
EXPECT_EQ(1716, file.GetPosition());
EXPECT_EQ(0, file.Seek(0, SEEK_SET));
EXPECT_EQ(sizeof(buf), file.Read(buf, sizeof(buf)));
file.Flush();
EXPECT_EQ(20, file.GetPosition());
EXPECT_TRUE(!memcmp("About\n-----\nXBMC is ", buf, sizeof(buf) - 1));
EXPECT_EQ(0, file.Seek(0, SEEK_SET));
EXPECT_EQ(-1, file.Seek(-100, SEEK_SET));
file.Close();
}
bool CPODocument::LoadFile(const std::string &pofilename)
{
XFILE::CFile file;
if (!file.Open(pofilename))
return false;
int64_t fileLength = file.GetLength();
if (fileLength < 18) // at least a size of a minimalistic header
{
file.Close();
CLog::Log(LOGERROR, "POParser: non valid length found for string file: %s", pofilename.c_str());
return false;
}
m_POfilelength = static_cast<size_t> (fileLength);
m_strBuffer.resize(m_POfilelength+1);
m_strBuffer[0] = '\n';
unsigned int readBytes = file.Read(&m_strBuffer[1], m_POfilelength);
file.Close();
if (readBytes != m_POfilelength)
{
CLog::Log(LOGERROR, "POParser: actual read data differs from file size, for string file: %s",
pofilename.c_str());
return false;
}
ConvertLineEnds(pofilename);
// we make sure, to have an LF at the end of buffer
if (*m_strBuffer.rbegin() != '\n')
{
m_strBuffer += "\n";
}
m_POfilelength = m_strBuffer.size();
if (GetNextEntry() && m_Entry.Type == MSGID_FOUND)
return true;
CLog::Log(LOGERROR, "POParser: unable to read PO file header from file: %s", pofilename.c_str());
return false;
}
//-------------------------------------------------------------------------------------------------------------------
bool Xcddb::queryCache( uint32_t discid )
{
if (cCacheDir.size() == 0)
return false;
XFILE::CFile file;
if (file.Open(GetCacheFile(discid)))
{
// Got a cachehit
char buffer[4096];
file.Read(buffer, 4096);
file.Close();
parseData( buffer );
return true;
}
return false;
}
//-------------------------------------------------------------------------------------------------------------------
bool Xcddb::queryCache( unsigned long discid )
{
if (cCacheDir.size() == 0)
return false;
XFILE::CFile file;
if (file.Open(GetCacheFile(discid)))
{
// Got a cachehit
char buffer[4096];
OutputDebugString ( "cddb local cache hit.\n" );
file.Read(buffer, 4096);
file.Close();
parseData( buffer );
return true;
}
return false;
}
bool CKaraokeLyricsTextKAR::Load()
{
XFILE::CFile file;
bool succeed = true;
m_reportedInvalidVarField = false;
// Clear the lyrics array
clearLyrics();
if ( !file.Open( m_midiFile ) )
return false;
m_midiSize = (unsigned int) file.GetLength();
if ( !m_midiSize )
return false; // shouldn't happen, but
file.Seek( 0, SEEK_SET );
m_midiData = new unsigned char [ m_midiSize ];
// Read the whole file
if ( !m_midiData || file.Read( m_midiData, m_midiSize) != m_midiSize )
return false;
file.Close();
// Parse MIDI
try
{
parseMIDI();
}
catch ( const char * p )
{
CLog::Log( LOGERROR, "KAR lyrics loader: cannot load file: %s", p );
succeed = false;
}
delete [] m_midiData;
m_midiData = 0;
return succeed;
}
HRESULT CNfoFile::Load(const CStdString& strFile)
{
Close();
XFILE::CFile file;
if (file.Open(strFile, true))
{
m_size = (int)file.GetLength();
m_doc = new char[m_size+1];
if (!m_doc)
{
file.Close();
return E_FAIL;
}
file.Read(m_doc, m_size);
m_doc[m_size] = 0;
file.Close();
return S_OK;
}
return E_FAIL;
}
void CGameClientInGameSaves::Load(GAME_MEMORY memoryType)
{
uint8_t *gameMemory = nullptr;
size_t size = 0;
try
{
m_dllStruct->GetMemory(memoryType, &gameMemory, &size);
}
catch (...)
{
CLog::Log(LOGERROR, "GAME: %s: Exception caught in GetMemory()", m_gameClient->ID().c_str());
}
const std::string path = GetPath(memoryType);
if (size > 0 && XFILE::CFile::Exists(path))
{
XFILE::CFile file;
if (file.Open(path))
{
ssize_t read = file.Read(gameMemory, size);
if (read == static_cast<ssize_t>(size))
{
CLog::Log(LOGINFO, "GAME: In-game saves (%s) loaded from %s", CGameClientTranslator::ToString(memoryType), path.c_str());
}
else
{
CLog::Log(LOGERROR, "GAME: Failed to read in-game saves (%s): %ld/%ld bytes read", CGameClientTranslator::ToString(memoryType), read, size);
}
}
else
{
CLog::Log(LOGERROR, "GAME: Unable to open in-game saves (%s) from file %s", CGameClientTranslator::ToString(memoryType), path.c_str());
}
}
else
{
CLog::Log(LOGDEBUG, "GAME: No in-game saves (%s) to load", CGameClientTranslator::ToString(memoryType));
}
}
TEST_F(Testlog, MemDump)
{
std::string logfile, logstring;
char buf[100];
unsigned int bytesread;
XFILE::CFile file;
CRegExp regex;
char refdata[] = "0123456789abcdefghijklmnopqrstuvwxyz";
std::string appName = CCompileInfo::GetAppName();
StringUtils::ToLower(appName);
logfile = CSpecialProtocol::TranslatePath("special://temp/") + appName + ".log";
EXPECT_TRUE(CLog::Init(CSpecialProtocol::TranslatePath("special://temp/").c_str()));
EXPECT_TRUE(XFILE::CFile::Exists(logfile));
CLog::MemDump(refdata, sizeof(refdata));
CLog::Close();
EXPECT_TRUE(file.Open(logfile));
while ((bytesread = file.Read(buf, sizeof(buf) - 1)) > 0)
{
buf[bytesread] = '\0';
logstring.append(buf);
}
file.Close();
EXPECT_FALSE(logstring.empty());
EXPECT_STREQ("\xEF\xBB\xBF", logstring.substr(0, 3).c_str());
EXPECT_TRUE(regex.RegComp(".*DEBUG: MEM_DUMP: Dumping from.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*DEBUG: MEM_DUMP: 0000 30 31 32 33.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*73 74 75 76 ghijklmnopqrstuv.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(XFILE::CFile::Delete(logfile));
}
unsigned int CFileUtils::LoadFile(const std::string &filename, void* &outputBuffer)
{
static const unsigned int max_file_size = 0x7FFFFFFF;
static const unsigned int min_chunk_size = 64*1024U;
static const unsigned int max_chunk_size = 2048*1024U;
outputBuffer = NULL;
if (filename.empty())
return 0;
XFILE::CFile file;
if (!file.Open(filename, READ_TRUNCATED))
return 0;
/*
GetLength() will typically return values that fall into three cases:
1. The real filesize. This is the typical case.
2. Zero. This is the case for some http:// streams for example.
3. Some value smaller than the real filesize. This is the case for an expanding file.
In order to handle all three cases, we read the file in chunks, relying on Read()
returning 0 at EOF. To minimize (re)allocation of the buffer, the chunksize in
cases 1 and 3 is set to one byte larger than the value returned by GetLength().
The chunksize in case 2 is set to the lowest value larger than min_chunk_size aligned
to GetChunkSize().
We fill the buffer entirely before reallocation. Thus, reallocation never occurs in case 1
as the buffer is larger than the file, so we hit EOF before we hit the end of buffer.
To minimize reallocation, we double the chunksize each read while chunksize is lower
than max_chunk_size.
*/
int64_t filesize = file.GetLength();
if (filesize > max_file_size)
{ /* file is too large for this function */
file.Close();
return 0;
}
unsigned int chunksize = (filesize > 0) ? (unsigned int)(filesize + 1) : CFile::GetChunkSize(file.GetChunkSize(), min_chunk_size);
unsigned char *inputBuff = NULL;
unsigned int inputBuffSize = 0;
unsigned int total_read = 0, free_space = 0;
while (true)
{
if (!free_space)
{ // (re)alloc
inputBuffSize += chunksize;
unsigned char *tempinputBuff = NULL;
if (inputBuffSize <= max_file_size)
tempinputBuff = (unsigned char *)realloc(inputBuff, inputBuffSize);
if (!tempinputBuff)
{
CLog::Log(LOGERROR, "%s unable to (re)allocate buffer of size %u for file \"%s\"", __FUNCTION__, inputBuffSize, filename.c_str());
free(inputBuff);
file.Close();
return 0;
}
inputBuff = tempinputBuff;
free_space = chunksize;
if (chunksize < max_chunk_size)
chunksize *= 2;
}
unsigned int read = file.Read(inputBuff + total_read, free_space);
free_space -= read;
total_read += read;
if (!read)
break;
}
file.Close();
if (total_read == 0)
{
free(inputBuff);
return 0;
}
if (total_read + 1 < inputBuffSize)
{
/* free extra memory if more than 1 byte (cases 1 and 3) */
unsigned char *tempinputBuff = (unsigned char *)realloc(inputBuff, total_read);
if (!tempinputBuff)
{
/* just a precaution, shouldn't really happen */
CLog::Log(LOGERROR, "%s unable to reallocate buffer for file \"%s\"", __FUNCTION__, filename.c_str());
free(inputBuff);
return 0;
}
inputBuff = tempinputBuff;
}
outputBuffer = (void *) inputBuff;
return total_read;
}
bool CBaseTexture::LoadFromFile(const CStdString& texturePath, unsigned int maxWidth, unsigned int maxHeight,
bool autoRotate, unsigned int *originalWidth, unsigned int *originalHeight)
{
if (URIUtils::GetExtension(texturePath).Equals(".dds"))
{ // special case for DDS images
CDDSImage image;
if (image.ReadFile(texturePath))
{
Update(image.GetWidth(), image.GetHeight(), 0, image.GetFormat(), image.GetData(), false);
return true;
}
return false;
}
#if defined(__APPLE__) && defined(__arm__)
XFILE::CFile file;
UInt8 *imageBuff = NULL;
int64_t imageBuffSize = 0;
//open path and read data to buffer
//this handles advancedsettings.xml pathsubstitution
//and resulting networking
if (file.Open(texturePath, 0))
{
imageBuffSize =file.GetLength();
imageBuff = new UInt8[imageBuffSize];
imageBuffSize = file.Read(imageBuff, imageBuffSize);
file.Close();
}
else
{
CLog::Log(LOGERROR, "Texture manager unable to open file %s", texturePath.c_str());
return false;
}
if (imageBuffSize <= 0)
{
CLog::Log(LOGERROR, "Texture manager read texture file failed.");
delete [] imageBuff;
return false;
}
// create the image from buffer;
CGImageSourceRef imageSource;
// create a CFDataRef using CFDataCreateWithBytesNoCopy and kCFAllocatorNull for deallocator.
// this allows us to do a nocopy reference and we handle the free of imageBuff
CFDataRef cfdata = CFDataCreateWithBytesNoCopy(NULL, imageBuff, imageBuffSize, kCFAllocatorNull);
imageSource = CGImageSourceCreateWithData(cfdata, NULL);
if (imageSource == nil)
{
CLog::Log(LOGERROR, "Texture manager unable to load file: %s", CSpecialProtocol::TranslatePath(texturePath).c_str());
CFRelease(cfdata);
delete [] imageBuff;
return false;
}
CGImageRef image = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);
int rotate = 0;
if (autoRotate)
{ // get the orientation of the image for displaying it correctly
CFDictionaryRef imagePropertiesDictionary = CGImageSourceCopyPropertiesAtIndex(imageSource,0, NULL);
if (imagePropertiesDictionary != nil)
{
CFNumberRef orientation = (CFNumberRef)CFDictionaryGetValue(imagePropertiesDictionary, kCGImagePropertyOrientation);
if (orientation != nil)
{
int value = 0;
CFNumberGetValue(orientation, kCFNumberIntType, &value);
if (value)
rotate = value - 1;
}
CFRelease(imagePropertiesDictionary);
}
}
CFRelease(imageSource);
unsigned int width = CGImageGetWidth(image);
unsigned int height = CGImageGetHeight(image);
m_hasAlpha = (CGImageGetAlphaInfo(image) != kCGImageAlphaNone);
if (originalWidth)
*originalWidth = width;
if (originalHeight)
*originalHeight = height;
// check texture size limits and limit to screen size - preserving aspectratio of image
if ( width > g_Windowing.GetMaxTextureSize() || height > g_Windowing.GetMaxTextureSize() )
{
float aspect;
if ( width > height )
{
aspect = (float)width / (float)height;
width = g_Windowing.GetWidth();
height = (float)width / (float)aspect;
}
else
{
aspect = (float)height / (float)width;
height = g_Windowing.GetHeight();
width = (float)height / (float)aspect;
}
CLog::Log(LOGDEBUG, "Texture manager texture clamp:new texture size: %i x %i", width, height);
}
// use RGBA to skip swizzling
Allocate(width, height, XB_FMT_RGBA8);
m_orientation = rotate;
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
// hw convert jmpeg to RGBA
CGContextRef context = CGBitmapContextCreate(m_pixels,
width, height, 8, GetPitch(), colorSpace,
kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
CGColorSpaceRelease(colorSpace);
// Flip so that it isn't upside-down
//CGContextTranslateCTM(context, 0, height);
//CGContextScaleCTM(context, 1.0f, -1.0f);
#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5
CGContextClearRect(context, CGRectMake(0, 0, width, height));
#else
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
// (just a way of checking whether we're running in 10.5 or later)
if (CGContextDrawLinearGradient == 0)
CGContextClearRect(context, CGRectMake(0, 0, width, height));
else
#endif
CGContextSetBlendMode(context, kCGBlendModeCopy);
#endif
//CGContextSetBlendMode(context, kCGBlendModeCopy);
CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
CGContextRelease(context);
CGImageRelease(image);
CFRelease(cfdata);
delete [] imageBuff;
#else
DllImageLib dll;
if (!dll.Load())
return false;
ImageInfo image;
memset(&image, 0, sizeof(image));
unsigned int width = maxWidth ? std::min(maxWidth, g_Windowing.GetMaxTextureSize()) : g_Windowing.GetMaxTextureSize();
unsigned int height = maxHeight ? std::min(maxHeight, g_Windowing.GetMaxTextureSize()) : g_Windowing.GetMaxTextureSize();
if(!dll.LoadImage(texturePath.c_str(), width, height, &image))
{
CLog::Log(LOGERROR, "Texture manager unable to load file: %s", texturePath.c_str());
return false;
}
m_hasAlpha = NULL != image.alpha;
Allocate(image.width, image.height, XB_FMT_A8R8G8B8);
if (autoRotate && image.exifInfo.Orientation)
m_orientation = image.exifInfo.Orientation - 1;
if (originalWidth)
*originalWidth = image.originalwidth;
if (originalHeight)
*originalHeight = image.originalheight;
unsigned int dstPitch = GetPitch();
unsigned int srcPitch = ((image.width + 1)* 3 / 4) * 4; // bitmap row length is aligned to 4 bytes
unsigned char *dst = m_pixels;
unsigned char *src = image.texture + (m_imageHeight - 1) * srcPitch;
for (unsigned int y = 0; y < m_imageHeight; y++)
{
unsigned char *dst2 = dst;
unsigned char *src2 = src;
for (unsigned int x = 0; x < m_imageWidth; x++, dst2 += 4, src2 += 3)
{
dst2[0] = src2[0];
dst2[1] = src2[1];
dst2[2] = src2[2];
dst2[3] = 0xff;
}
src -= srcPitch;
dst += dstPitch;
}
if(image.alpha)
{
dst = m_pixels + 3;
src = image.alpha + (m_imageHeight - 1) * m_imageWidth;
for (unsigned int y = 0; y < m_imageHeight; y++)
{
unsigned char *dst2 = dst;
unsigned char *src2 = src;
for (unsigned int x = 0; x < m_imageWidth; x++, dst2+=4, src2++)
*dst2 = *src2;
src -= m_imageWidth;
dst += dstPitch;
}
}
dll.ReleaseImage(&image);
#endif
ClampToEdge();
return true;
}
bool CScraperUrl::Get(const SUrlEntry& scrURL, std::string& strHTML, XFILE::CCurlFile& http, const CStdString& cacheContext)
{
CURL url(scrURL.m_url);
http.SetReferer(scrURL.m_spoof);
CStdString strCachePath;
if (scrURL.m_isgz)
http.SetContentEncoding("gzip");
if (!scrURL.m_cache.IsEmpty())
{
URIUtils::AddFileToFolder(g_advancedSettings.m_cachePath,
"scrapers/"+cacheContext+"/"+scrURL.m_cache,
strCachePath);
if (XFILE::CFile::Exists(strCachePath))
{
XFILE::CFile file;
if (file.Open(strCachePath))
{
char* temp = new char[(int)file.GetLength()];
file.Read(temp,file.GetLength());
strHTML.clear();
strHTML.append(temp,temp+file.GetLength());
file.Close();
delete[] temp;
return true;
}
}
}
CStdString strHTML1(strHTML);
if (scrURL.m_post)
{
CStdString strOptions = url.GetOptions();
strOptions = strOptions.substr(1);
url.SetOptions("");
if (!http.Post(url.Get(), strOptions, strHTML1))
return false;
}
else
if (!http.Get(url.Get(), strHTML1))
return false;
strHTML = strHTML1;
if (scrURL.m_url.Find(".zip") > -1 )
{
XFILE::CZipFile file;
CStdString strBuffer;
int iSize = file.UnpackFromMemory(strBuffer,strHTML,scrURL.m_isgz);
if (iSize)
{
strHTML.clear();
strHTML.append(strBuffer.c_str(),strBuffer.data()+iSize);
}
}
if (!scrURL.m_cache.IsEmpty())
{
CStdString strCachePath;
URIUtils::AddFileToFolder(g_advancedSettings.m_cachePath,
"scrapers/"+cacheContext+"/"+scrURL.m_cache,
strCachePath);
XFILE::CFile file;
if (file.OpenForWrite(strCachePath,true))
file.Write(strHTML.data(),strHTML.size());
file.Close();
}
return true;
}
/* Test case to test for graceful handling of corrupted input.
* NOTE: The test case is considered a "success" as long as the corrupted
* file was successfully generated and the test case runs without a segfault.
*/
TEST(TestRarFile, CorruptedFile)
{
XFILE::CFile *file;
char buf[16];
memset(&buf, 0, sizeof(buf));
CStdString reffilepath, strrarpath, strpathinrar, str;
CFileItemList itemlist;
unsigned int size, i;
int64_t count = 0;
reffilepath = XBMC_REF_FILE_PATH("xbmc/filesystem/test/reffile.txt.rar");
ASSERT_TRUE((file = XBMC_CREATECORRUPTEDFILE(reffilepath, ".rar")) != NULL);
std::cout << "Reference file generated at '" << XBMC_TEMPFILEPATH(file) <<
"'\n";
URIUtils::CreateArchivePath(strrarpath, "rar", XBMC_TEMPFILEPATH(file), "");
if (!XFILE::CDirectory::GetDirectory(strrarpath, itemlist, "",
XFILE::DIR_FLAG_NO_FILE_DIRS))
{
XBMC_DELETETEMPFILE(file);
SUCCEED();
return;
}
if (itemlist.IsEmpty())
{
XBMC_DELETETEMPFILE(file);
SUCCEED();
return;
}
strpathinrar = itemlist[0]->GetPath();
if (!file->Open(strpathinrar))
{
XBMC_DELETETEMPFILE(file);
SUCCEED();
return;
}
std::cout << "file->GetLength(): " <<
testing::PrintToString(file->GetLength()) << "\n";
std::cout << "file->Seek(file->GetLength() / 2, SEEK_CUR) return value: " <<
testing::PrintToString(file->Seek(file->GetLength() / 2, SEEK_CUR)) << "\n";
std::cout << "file->Seek(0, SEEK_END) return value: " <<
testing::PrintToString(file->Seek(0, SEEK_END)) << "\n";
std::cout << "file->Seek(0, SEEK_SET) return value: " <<
testing::PrintToString(file->Seek(0, SEEK_SET)) << "\n";
std::cout << "File contents:\n";
while ((size = file->Read(buf, sizeof(buf))) > 0)
{
str.Format(" %08X", count);
std::cout << str << " ";
count += size;
for (i = 0; i < size; i++)
{
str.Format("%02X ", buf[i]);
std::cout << str;
}
while (i++ < sizeof(buf))
std::cout << " ";
std::cout << " [";
for (i = 0; i < size; i++)
{
if (buf[i] >= ' ' && buf[i] <= '~')
std::cout << buf[i];
else
std::cout << ".";
}
std::cout << "]\n";
}
file->Close();
XBMC_DELETETEMPFILE(file);
}
bool CGUISound::LoadWav(const CStdString& strFile, WAVEFORMATEX* wfx, LPBYTE* ppWavData, int* pDataSize)
{
XFILE::CFile file;
if (!file.Open(strFile))
return false;
// read header
WAVE_RIFFHEADER riffh;
file.Read(&riffh, sizeof(WAVE_RIFFHEADER));
// file valid?
if (strncmp(riffh.riff, "RIFF", 4)!=0 && strncmp(riffh.rifftype, "WAVE", 4)!=0)
{
file.Close();
return false;
}
long offset=0;
offset += sizeof(WAVE_RIFFHEADER);
offset -= sizeof(WAVE_CHUNK);
// parse chunks
do
{
WAVE_CHUNK chunk;
// always seeking to the start of a chunk
file.Seek(offset + sizeof(WAVE_CHUNK), SEEK_SET);
file.Read(&chunk, sizeof(WAVE_CHUNK));
if (!strncmp(chunk.chunk_id, "fmt ", 4))
{ // format chunk
memset(wfx, 0, sizeof(WAVEFORMATEX));
file.Read(wfx, 16);
// we only need 16 bytes of the fmt chunk
if (chunk.chunksize-16>0)
file.Seek(chunk.chunksize-16, SEEK_CUR);
}
else if (!strncmp(chunk.chunk_id, "data", 4))
{ // data chunk
*ppWavData=new BYTE[chunk.chunksize+1];
file.Read(*ppWavData, chunk.chunksize);
*pDataSize=chunk.chunksize;
if (chunk.chunksize & 1)
offset++;
}
else
{ // other chunk - unused, just skip
file.Seek(chunk.chunksize, SEEK_CUR);
}
offset+=(chunk.chunksize+sizeof(WAVE_CHUNK));
if (offset & 1)
offset++;
} while (offset+(int)sizeof(WAVE_CHUNK) < riffh.filesize);
file.Close();
return (*ppWavData!=NULL);
}