static long
FileLoadMKext( const char * dirSpec, const char * extDirSpec )
{
long ret, flags;
u_int32_t time, time2;
char altDirSpec[512];
snprintf(altDirSpec, sizeof(altDirSpec), "%s%s", dirSpec, extDirSpec);
ret = GetFileInfo(altDirSpec, "Extensions.mkext", &flags, &time);
if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeFlat))
{
ret = GetFileInfo(dirSpec, "Extensions", &flags, &time2);
if ((ret != 0)
|| ((flags & kFileTypeMask) != kFileTypeDirectory)
|| (((gBootMode & kBootModeSafe) == 0) && (time == (time2 + 1))))
{
snprintf(gDriverSpec, sizeof(altDirSpec) + 18, "%sExtensions.mkext", altDirSpec);
verbose("LoadDrivers: Loading from [%s]\n", gDriverSpec);
if (LoadDriverMKext(gDriverSpec) == 0) {
return 0;
}
}
}
return -1;
}
void CSpyUserPanel::OnSpyFileItemActivated(wxListEvent& event)
{
wxString strCurLocaitoin = m_pFileLocationText->GetValue();
bool bIsRootLocation = strCurLocaitoin.Length() == 3 && strCurLocaitoin[1] == _T(':');
wxString strItem = event.GetItem().GetText();
wxString strNewLocation = strItem;
if (strCurLocaitoin != _T("我的电脑"))
{
if (*strCurLocaitoin.rbegin() != _T('/'))
{
strCurLocaitoin.append(_T("/"));
}
strNewLocation = strCurLocaitoin.append(strItem);
}
TCHAR szPath[MAX_PATH];
if (strItem == _T("..") && bIsRootLocation)
{
szPath[0] = 0;
}
else
{
CFilePathTool::GetInstance()->Canonical(szPath, strNewLocation.c_str());
}
GetFileInfo(szPath, false);
}
cFileInfoMenu::cFileInfoMenu(std::string mrl) : cOsdMenu( tr("File Info:"), 12)
{
//set title
//SetTitle(tr("mediaplayer - Id3 Info:"));
mrl_ = mrl;
fileInfoVec_ = GetFileInfo(mrl_);
// Get title
std::string title;
TagLib::FileRef f( mrl.c_str() );
if(!f.isNull() && f.tag())
{
TagLib::Tag *tag = f.tag();
// unicode = false
title = tag->title().stripWhiteSpace().toCString(false) ;
if (title.size())
{
char buffer[128];
snprintf(buffer, 127, "File Info: %s", title.c_str());
SetTitle(buffer);
printf("setting title to : %s\n", buffer);
}
}
ShowInfo();
}
///////////////////////////////////////////////////////////////////////////////
//
// Search for the target using the vPath
fileinfo* mhmakefileparser::SearchvPath(const fileinfo* pTarget)
{
string TargetName=pTarget->GetName();
vector< pair< string, refptr<fileinfoarray> > >::iterator vPathIt=m_vPath.begin();
while (vPathIt!=m_vPath.end())
{
matchres Res;
if (PercentMatch(TargetName,vPathIt->first,&Res))
{
fileinfoarray::iterator pIt=vPathIt->second->begin();
while (pIt!=vPathIt->second->end())
{
fileinfo* pNewTarget=GetFileInfo(TargetName,*pIt);
mh_time_t TargetDate=StartBuildTarget(pNewTarget,false);
if (!TargetDate.IsDateValid())
TargetDate=WaitBuildTarget(pNewTarget);
if (pNewTarget->GetDate().DoesExist())
return pNewTarget;
pIt++;
}
}
vPathIt++;
}
return NULL;
}
void UnixFileSystemBase::GetFiles(const String& path, Array<FileInfo>& list)
{
String prefix =
path.Length() > 0 && path.Last() != '/' ?
path + "/" :
path;
DIR *dp;
struct dirent *ep;
if ((dp = opendir(prefix.Ptr())) == NULL)
XLI_THROW_FILE_NOT_FOUND(prefix);
if (prefix == "./")
prefix = "";
while ((ep = readdir(dp)) != NULL)
{
String fn = ep->d_name;
if (fn == "." || fn == "..")
continue;
FileInfo info;
if (GetFileInfo(prefix + fn, info))
list.Add(info);
}
closedir(dp);
}
FolderInfo FileSystem::GetFolderInfo(const String& path) const
{
FolderInfo res;
res.path = path;
WIN32_FIND_DATA f;
HANDLE h = FindFirstFile(path + "/*", &f);
if (h != INVALID_HANDLE_VALUE)
{
do
{
if (strcmp(f.cFileName, ".") == 0 || strcmp(f.cFileName, "..") == 0)
continue;
if (f.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
res.folders.Add(GetFolderInfo(path + "/" + f.cFileName));
else
res.files.Add(GetFileInfo(path + "/" + f.cFileName));
} while (FindNextFile(h, &f));
}
else
mInstance->mLog->Error("Failed GetPathInfo: Error opening directory " + path);
FindClose(h);
return res;
}
int nb_qfileinfo(int handle)
{
int i;
int rc;
char FileName[128];
char temp[512];
DWORD gle;
sprintf(FileName, "Thread_%05d.log", ProcessNumber);
if ((i = FindHandle(handle)) == -1)
return(-1);
StartFirstTimer();
rc = GetFileInfo(ftable[i].name, ftable[i].fd, NULL, NULL, NULL, NULL, NULL, NULL);
gle = GetLastError();
if (!rc)
{
EndFirstTimer(CMD_QUERY_FILE_INFO, 0);
LeaveThread(0, "", CMD_QUERY_FILE_INFO);
sprintf(temp, "File: qfileinfo failed for %s GLE(0x%x)\n", ftable[i].name, gle);
if (verbose)
printf("%s", temp);
LogMessage(ProcessNumber, HostName, FileName, temp, LogID);
return(-1);
}
EndFirstTimer(CMD_QUERY_FILE_INFO, 1);
return(0);
}
bool GetFileList(const string &sStoragePath, string &sOutResponse)
{
START_FUNCTION_BOOL();
ASSERTE(!sStoragePath.empty());
const sizeint siStoragePathLength = sStoragePath.length();
string_v vsFilesList;
sizeint siFilesCount = FileUtils::GetFileListRecursive(sStoragePath.c_str(), vsFilesList);
string sResult;
sizeint siEstimatedLength = (sStoragePath.length() + 1) * siFilesCount;
sResult.reserve(siEstimatedLength);
for (sizeint siIndex = 0; siIndex < siFilesCount; ++siIndex)
{
string &sCurrentFile = vsFilesList[siIndex];
ASSERTE(sCurrentFile.length() > siStoragePathLength);
string sFileInfo;
if (GetFileInfo(sCurrentFile, sFileInfo))
{
string sCurrentFileItem = sCurrentFile.substr(siStoragePathLength) + sFileInfo;
sResult.append(sCurrentFileItem);
}
}
sOutResponse = sResult;
END_FUNCTION_BOOL();
}
bool CZipArchive::ExtractFile(WORD uIndex, LPCTSTR lpszPath, DWORD nBufSize)
{
if (!nBufSize)
return false;
CFileHeader header;
GetFileInfo(header, uIndex); // to ensure that slash and oem conversions take place
CString szFile = lpszPath;
szFile.TrimRight(_T("\\"));
szFile += _T("\\") + GetFileDirAndName(header.m_szFileName); // just in case in the archive there are file names with drives
if (IsFileDirectory(uIndex))
{
ForceDirectory(szFile);
SetFileAttributes(szFile, header.m_uExternalAttr);
}
else
{
if (!OpenFile(uIndex))
return false;
ForceDirectory(GetFilePath(szFile));
CFile f(szFile, CFile::modeWrite | CFile::modeCreate | CFile::shareDenyWrite);
DWORD iRead;
CAutoBuffer buf(nBufSize);
do
{
iRead = ReadFile(buf, buf.GetSize());
if (iRead)
f.Write(buf, iRead);
}
while (iRead == buf.GetSize());
CloseFile(f);
}
return true;
}
bool FStreamingNetworkPlatformFile::IsReadOnly(const TCHAR* Filename)
{
FFileInfo Info;
GetFileInfo(Filename, Info);
return Info.ReadOnly;
}
FDateTime FStreamingNetworkPlatformFile::GetAccessTimeStamp(const TCHAR* Filename)
{
FFileInfo Info;
GetFileInfo(Filename, Info);
return Info.AccessTimeStamp;
}
// Finds the first file of a given directory. Must be used in conjunction with
// the FindNext and FindClose methods. FindClose needn't be called if the call
// to FindFirst returned false.
//
// Returns:
// true if a file was found
// false if no file was found, or if there was an error
//
// Example:
//
// CiPoTApi iPodApi;
// t_iPodFileInfo info;
// bool bFile;
// t_iPodError status = iPodApi.OpenSession();
//
// if (status == IPOD_ERR_OK) {
// bFile = iPodApi.FindFirst(remotePath, &info);
// while (bFile) {
// printf("%s\n", info.findData.cFileName);
// bFile = iPodApi.FindNext(&info);
// }
// iPodApi.FindClose(&info);
//
bool CiPoTApi::FindFirst(char *remotePath, t_iPodFileInfo *pInfo)
{
t_AFCDirectory *pHandle;
afc_error_t ret;
char *pEntry;
CMacPath MacPath;
pInfo->pHandle = NULL;
pInfo->remotePath = NULL;
MacPath.SetWindowsPath(remotePath);
ret = AFCDirectoryOpen(m_iPodConnection, MacPath.GetBuffer(), &pHandle);
if (ret)
return false;
ret = AFCDirectoryRead(m_iPodConnection, pHandle, &pEntry);
if (ret || pEntry == NULL) {
// Broken link?
AFCDirectoryClose(m_iPodConnection, pHandle);
return false;
}
pInfo->remotePath = strdup(remotePath);
pInfo->pHandle = pHandle;
// Now, a special case with the Applications folder
pInfo->appFolder = bTranslateApps && (
!strcmp(remotePath, _T("\\User\\Applications")) ||
!strcmp(remotePath, _T("\\var\\mobile\\Applications")) ||
!strcmp(remotePath, _T("\\private\\var\\mobile\\Applications")));
MacPath.SetString(pEntry);
MacPath.GetWindowsPath(pInfo->findData.cFileName);
GetFileInfo(0, pInfo);
return true;
}
HRESULT CMediaFileList::AddAudioFile(BSTR FilePath, IMediaFile **ppResult)
{
HRESULT hr = CoCreateInstance(CLSID_MediaFile, NULL,
CLSCTX_INPROC_SERVER,
IID_IMediaFile,
(void **)ppResult);
if (FAILED(hr) || *ppResult == NULL)
return E_POINTER;
(*ppResult)->AddRef();
(*ppResult)->put_FilePath(FilePath);
double dDuration = 0;
hr = GetFileInfo(FilePath, 0, &dDuration, 0, 0, 0, 0, 0, 0);
if (SUCCEEDED(hr))
{
(*ppResult)->put_Duration(dDuration);
}
(*ppResult)->put_StartOffset(GetCurrentAudioLength());
m_audioList.AddTail(*ppResult);
(*ppResult)->AddRef();
return S_OK;
}
static void GetAvailableThemes(std::vector<AvailableTheme> * outThemes)
{
Guard::ArgumentNotNull(outThemes, GUARD_LINE);
outThemes->clear();
NumPredefinedThemes = 0;
for (auto predefinedTheme : PredefinedThemes)
{
AvailableTheme theme {};
theme.Name = predefinedTheme.Theme->Name;
outThemes->push_back(std::move(theme));
NumPredefinedThemes++;
}
auto themesPattern = Path::Combine(GetThemePath(), "*.json");
auto scanner = std::unique_ptr<IFileScanner>(Path::ScanDirectory(themesPattern, true));
while (scanner->Next())
{
auto fileInfo = scanner->GetFileInfo();
auto name = Path::GetFileNameWithoutExtension(std::string(fileInfo->Name));
AvailableTheme theme {};
theme.Name = name;
theme.Path = GetThemeFileName(theme.Name);
outThemes->push_back(std::move(theme));
if (Path::Equals(CurrentThemePath, scanner->GetPath()))
{
ActiveAvailableThemeIndex = outThemes->size() - 1;
}
}
}
void mhmakefileparser::SetvPath(const string &Pattern, const string &Path)
{
// First create the array of directory from the Path parameter. For now all entries need to
// be valid directories (extra checking). This could be improved by checking if there
// is a rule for creating the directory entry, but like first said, not for now.
refptr<fileinfoarray> pDirArray=new fileinfoarray;
const char *pTmp=Path.c_str();
while (*pTmp)
{
string Item;
pTmp=NextItem(pTmp,Item," \t:;");
if (!Item.empty())
{
fileinfo *pDir=GetFileInfo(Item,m_MakeDir);
if (!pDir->IsDir())
{
#ifdef WIN32
// On windows this could happen if a full pathname was specified, so we try together
// with the next item to check if this is not a valid directories
// but only if the the length of the item was 1 namely the driver letter
if (Item.length()==1)
{
string Rest;
pTmp=NextItem(pTmp,Rest," \t:;");
pDir=GetFileInfo(Item+":"+Rest,m_MakeDir);
#ifdef _DEBUG
if (g_PrintAdditionalInfo && !pDir->IsDir())
throw(pDir->GetFullFileName()+" is not a valid directory.");
#endif
}
#ifdef _DEBUG
else if (g_PrintAdditionalInfo)
cout << pDir->GetFullFileName() << " is not a valid directory.\n";
#endif
#else
#ifdef _DEBUG
if (g_PrintAdditionalInfo)
cout << pDir->GetFullFileName() << " is not a valid directory.\n";
#endif
#endif
}
pDirArray->push_back(pDir);
}
}
m_vPath.push_back(pair<string, refptr<fileinfoarray> >(Pattern,pDirArray));
}
long
FileLoadDrivers( char * dirSpec, long plugin )
{
long ret, length, flags, time, bundleType;
long long index;
long result = -1;
const char * name;
if ( !plugin )
{
// First try 10.6's path for loading Extensions.mkext.
if (FileLoadMKext(dirSpec, "Caches/com.apple.kext.caches/Startup/") == 0)
return 0;
// Next try the legacy path.
else if (FileLoadMKext(dirSpec, "") == 0)
return 0;
strcat(dirSpec, "Extensions");
}
index = 0;
while (1) {
ret = GetDirEntry(dirSpec, &index, &name, &flags, &time);
if (ret == -1) break;
// Make sure this is a directory.
if ((flags & kFileTypeMask) != kFileTypeDirectory) continue;
// Make sure this is a kext.
length = strlen(name);
if (strcmp(name + length - 5, ".kext")) continue;
// Save the file name.
strcpy(gFileName, name);
// Determine the bundle type.
sprintf(gTempSpec, "%s/%s", dirSpec, gFileName);
ret = GetFileInfo(gTempSpec, "Contents", &flags, &time);
if (ret == 0) bundleType = kCFBundleType2;
else bundleType = kCFBundleType3;
if (!plugin)
sprintf(gDriverSpec, "%s/%s/%sPlugIns", dirSpec, gFileName,
(bundleType == kCFBundleType2) ? "Contents/" : "");
ret = LoadDriverPList(dirSpec, gFileName, bundleType);
if (result != 0)
result = ret;
if (!plugin)
FileLoadDrivers(gDriverSpec, 1);
}
return result;
}
void HibernateEnabler_hook(void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6)
{
bool tryresume,tryresumedefault, forceresume;
if (!getBoolForKey (kWake, &tryresume, DEFAULT_BOOT_CONFIG))
{
tryresume = true;
tryresumedefault = true;
}
else
{
tryresumedefault = false;
}
if (!getBoolForKey (kForceWake, &forceresume, DEFAULT_BOOT_CONFIG))
{
forceresume = false;
}
if (forceresume)
{
tryresume = true;
tryresumedefault = false;
}
while (tryresume) {
const char *tmp, *val;
int len, ret = -1;
long flags, sleeptime;
BVRef bvr;
if (!getValueForKey(kWakeImage, &val, &len, DEFAULT_BOOT_CONFIG))
val="/private/var/vm/sleepimage";
// Do this first to be sure that root volume is mounted
ret = GetFileInfo(0, val, &flags, &sleeptime);
if ((bvr = getBootVolumeRef(val, &tmp)) == NULL)
break;
// Can't check if it was hibernation Wake=y is required
if (bvr->modTime == 0 && tryresumedefault)
break;
if ((ret != 0) || ((flags & kFileTypeMask) != kFileTypeFlat))
break;
if (!forceresume && ((sleeptime+3)<bvr->modTime))
{
printf ("Hibernate image is too old by %d seconds. Use ForceWake=y to override\n",bvr->modTime-sleeptime);
break;
}
HibernateBoot((char *)val);
break;
}
}
int KHttpFile::Download()
{
int nRetCode = false;
int nResult = false;
int nRetryCount = 0;
nRetCode = GetFileInfo();
KGLOG_PROCESS_ERROR(nRetCode);
while (nRetryCount <= 5)
{
if (m_nFileSize == m_nDownloadedSize)
{
m_nErrorCode = dec_err_success;
goto Exit1;
}
nRetCode = m_Downloader.Download(m_strUrl.c_str(), m_strFile.c_str());
switch(nRetCode)
{
case HTTP_RESULT_SUCCESS:
case HTTP_RESULT_SAMEAS:
m_nErrorCode = dec_err_success;
goto Exit1;
break;
case HTTP_RESULT_STOP:
m_nErrorCode = dec_err_stop;
goto Exit0;
break;
case HTTP_RESULT_FAIL:
m_nErrorCode = dec_err_disconnection;
KGLogPrintf(KGLOG_INFO, "disconnection retry %d", nRetryCount++);
Sleep(5000);
break;
case HTTP_RESULT_REDIRECT_FTP:
case HTTP_RESULT_REDIRECT_HTTP:
m_nErrorCode = dec_err_cannotconnect;
KGLogPrintf(KGLOG_INFO, "cannotconnect retry %d", nRetryCount++);
Sleep(5000);
break;
default:
m_nErrorCode = dec_err_cannotconnect;
KGLOG_PROCESS_ERROR(false && "unknow result");
break;
}
}
Exit1:
nResult = true;
Exit0:
KGLogPrintf(KGLOG_INFO, "download result= %d, filename = %s", m_nErrorCode, m_strFile.c_str());
return nResult;
}
CDateTime CLocalFileSystem::GetModificationTime( const wxString& path)
{
CDateTime mtime;
bool tmp;
if (GetFileInfo(path, tmp, 0, &mtime, 0) == unknown)
mtime = CDateTime();
return mtime;
}
// This is called once for each output line.
// In this example the input data is obtained pixel by pixel from the input image
// using the GetPixel method of the GDI+ Bitmap object created from the source image
// file above.
//
CNCSError ECWDEMCompressor::WriteReadLine(UINT32 nNextLine, void **ppInputArray)
{
CNCSError Error = NCS_SUCCESS;
NCSFileViewFileInfoEx *pInfo = GetFileInfo();
IFECW->WriteReadLineCallback(nNextLine, ppInputArray, pInfo->nSizeX, pInfo->eCellType);
return NCS_SUCCESS;
} // ECWDEMCompressor::WriteReadLine
BOOL CUnzipper::GetFileInfo(int nFile, UZ_FileInfo& info)
{
if (!m_uzFile)
return FALSE;
if (!GotoFile(nFile))
return FALSE;
return GetFileInfo(info);
}
FileWatcher::FileEventFlags FileWatcher::Worker::UpdateFileInfo(boost::filesystem::path path)
{
FileEventFlags flags = FileEventFlags::Nothing;
if (boost::filesystem::exists(path))
{
FileInfo fi = GetFileInfo(path);
auto lastFileInfoIt = m_FileInfo.find(path);
if (lastFileInfoIt != m_FileInfo.end())
{
FileInfo lastFileInfo = lastFileInfoIt->second;
if (fi.Size != lastFileInfo.Size)
{
LOG_DEBUG("FileWatcher: \"%s\" size changed!", path.string().c_str());
flags = flags | FileEventFlags::SizeChanged;
}
if (fi.Timestamp != lastFileInfo.Timestamp)
{
LOG_DEBUG("FileWatcher: \"%s\" timestamp changed!", path.string().c_str());
flags = flags | FileEventFlags::TimestampChanged;
}
}
else
{
LOG_DEBUG("FileWatcher: \"%s\" was created!", path.string().c_str());
flags = flags | FileEventFlags::Created;
}
m_FileInfo[path] = GetFileInfo(path);
}
else
{
auto fileInfoIt = m_FileInfo.find(path);
if (fileInfoIt != m_FileInfo.end())
{
m_FileInfo.erase(fileInfoIt);
LOG_DEBUG("FileWatcher: \"%s\" was deleted!", path.string().c_str());
flags = flags | FileEventFlags::Deleted;
}
}
return flags;
}
wxLongLong CLocalFileSystem::GetSize(wxString const& path, bool* isLink)
{
wxLongLong ret = -1;
bool tmp{};
local_fileType t = GetFileInfo(path, isLink ? *isLink : tmp, &ret, 0, 0);
if( t != file ) {
ret = -1;
}
return ret;
}
bool CServerFileManageHandle::DowndFileDir(LPCWSTR szPath, LPCWSTR szRemote)
{
std::wstring strPath = szRemote;
if( szPath[lstrlen(szPath) -1] != _T('\\') )
strPath += _T("\\");
{{
std::wstring strPath = szPath;
if( szPath[lstrlen(szPath) -1] != _T('\\') )
strPath += _T("\\");
BOOL bOK = CreateDirectory(strPath.c_str(), NULL);
if(!bOK)
return false;
}}
File_Info_Vector Vector;
bool bIsOk = GetFileInfo(strPath.c_str(), &Vector);
if(!bIsOk)
return false;
DWORD dwFileCount = Vector.size();
for(DWORD i = 0; i < Vector.size(); i++)
{
if(lstrcmp(Vector[i].cFileName, _T(".")) == 0)
continue;
if(lstrcmp(Vector[i].cFileName, _T("..")) == 0)
continue;
std::wstring strPath = szPath;
if( szPath[lstrlen(szPath) -1] != _T('\\') )
strPath += _T("\\");
std::wstring strRemote = szRemote;
if( szRemote[lstrlen(szRemote) -1] != _T('\\') )
strRemote += _T("\\");
if(Vector[i].bIsDir)
{
strPath += Vector[i].cFileName;
strPath += _T("\\");
strRemote += Vector[i].cFileName;
strRemote += _T("\\");
bIsOk = DowndFileDir(strPath.c_str(), strRemote.c_str());
if(!bIsOk)
return false;
}
else
{
strPath += Vector[i].cFileName;
strRemote += Vector[i].cFileName;
bIsOk = DowndFile(strPath.c_str(), strRemote.c_str());
if(!bIsOk)
return false;
}
}
return true;
}
void FileWatcher::Worker::AddWatch(std::string path, FileEventCallback_t callback)
{
m_Mutex.lock();
boost::filesystem::path bpath(path);
m_FileCallbacks[bpath] = callback;
if (boost::filesystem::exists(bpath))
{
m_FileInfo[bpath] = GetFileInfo(bpath);
}
m_Mutex.unlock();
}
void LogException(BadCodeException &e) {
try {
auto info = GetFileInfo(e.location);
std::cerr << info.generateReport(e.message) << std::endl;
} catch (InternalCompilerError &ice) {
std::cerr << ice.message << " The error was: '" << e.message << "'"
<< std::endl;
} catch (...) {
std::cerr << "There was an error in the above program." << std::endl;
// And the above compiler, apparently
}
}
void mhmakefileparser::SplitToItems(const string &String,vector<fileinfo*> &Items) const
{
const char *pTmp=String.c_str();
while (*pTmp)
{
string Item;
pTmp=NextItem(pTmp,Item);
if (!Item.empty())
{
Items.push_back(GetFileInfo(Item,m_MakeDir));
}
}
}
void mhmakefileparser::ParseBuildedIncludeFiles()
{
vector<string>::iterator It=m_ToBeIncludeAfterBuild.begin();
while (It!=m_ToBeIncludeAfterBuild.end())
{
int result=ParseFile(GetFileInfo(*It,m_MakeDir));
if (result)
{
throw string("Error parsing ")+*It;
}
It++;
}
}
//根据MD5值返回文件全路径
acl::string CResourceMgr::GetFileFullPath(acl::string md5)
{
acl::string info = GetFileInfo(md5);
std::vector<acl::string> vField = info.split2(SPLITOR_OF_FILE_INFO);
if (vField.size() > 3)
{
//key：md5, value:文件名|文件路径|MD5|文件大小
return vField[1];
}
return "";
}
bool Buffer::LoadFromFile(std::string filename, SoundType sound)
{
m_sound = sound;
GetLogger()->Debug("Loading audio file: %s\n", filename.c_str());
auto file = CResourceManager::GetSNDFileHandler(filename);
GetLogger()->Trace(" channels %d\n", file->GetFileInfo().channels);
GetLogger()->Trace(" format %d\n", file->GetFileInfo().format);
GetLogger()->Trace(" frames %d\n", file->GetFileInfo().frames);
GetLogger()->Trace(" samplerate %d\n", file->GetFileInfo().samplerate);
GetLogger()->Trace(" sections %d\n", file->GetFileInfo().sections);
if (!file->IsOpen())
{
GetLogger()->Warn("Could not load file %s. Reason: %s\n", filename.c_str(), file->GetLastError().c_str());
m_loaded = false;
return false;
}
alGenBuffers(1, &m_buffer);
if (CheckOpenALError())
{
GetLogger()->Warn("Could not create audio buffer. Code: %d\n", GetOpenALErrorCode());
m_loaded = false;
return false;
}
// read chunks of 4096 samples
std::vector<uint16_t> data;
std::array<int16_t, 4096> buffer;
data.reserve(file->GetFileInfo().frames);
std::size_t read = 0;
while ((read = file->Read(buffer.data(), buffer.size())) != 0)
{
data.insert(data.end(), buffer.begin(), buffer.begin() + read);
}
ALenum format = file->GetFileInfo().channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
alBufferData(m_buffer, format, &data.front(), data.size() * sizeof(uint16_t), file->GetFileInfo().samplerate);
m_duration = static_cast<float>(file->GetFileInfo().frames) / file->GetFileInfo().samplerate;
m_loaded = true;
return true;
}
