{

wxMemorySize avail;

#if defined(__WXMAC__)

mach_port_t port = mach_host_self();

mach_msg_type_number_t cnt = HOST_VM_INFO_COUNT;

vm_statistics_data_t stats;

vm_size_t pagesize = 0;

memset(&stats, 0, sizeof(stats));

host_page_size(port, &pagesize);

host_statistics(port, HOST_VM_INFO, (host_info_t) &stats, &cnt);

avail = stats.free_count * pagesize;

#else

avail = wxGetFreeMemory();

#endif

return avail;

wxArrayString& filePathArray, // output: all files in dirPath tree

wxString dirspec,

wxString filespec,

bool bFiles, bool bDirs,

int progress_count = 0,

int progress_bias = 0,

ProgressDialog* progress = NULL)

{

int count=0;

bool cont;

wxDir dir(dirPath);

if(dir.IsOpened()){

wxString name;

// Don't delete files from a selective top level, e.g. if handed "projects*" as the

// directory specifier.

if (bFiles && dirspec.IsEmpty() ){

cont= dir.GetFirst(&name, filespec, wxDIR_FILES | wxDIR_HIDDEN | wxDIR_NO_FOLLOW);

while ( cont ){

wxString filepath = dirPath + wxFILE_SEP_PATH + name;

count++;

filePathArray.Add(filepath);

cont = dir.GetNext(&name);

if (progress)

progress->Update(count + progress_bias,

progress_count);

}

}

cont= dir.GetFirst(&name, dirspec, wxDIR_DIRS | wxDIR_NO_FOLLOW);

while ( cont ){

wxString subdirPath = dirPath + wxFILE_SEP_PATH + name;

count += RecursivelyEnumerate(

subdirPath, filePathArray, wxEmptyString,filespec,

bFiles, bDirs,

progress_count, count + progress_bias,

progress);

cont = dir.GetNext(&name);

}

}

if (bDirs) {

filePathArray.Add(dirPath);

count++;

}

return count;

wxArrayString& filePathArray, // output: all files in dirPath tree

wxString dirspec,

wxString filespec,

bool bFiles, bool bDirs,

int progress_count,

const wxChar* message)

{

Maybe<ProgressDialog> progress{};

if (message)

progress.create( _("Progress"), message );

int count = RecursivelyEnumerate(

dirPath, filePathArray, dirspec,filespec,

bFiles, bDirs,

progress_count, 0,

progress.get());

return count;

{

bool bContinue;

int nCount = 0;

wxDir dir(dirPath);

if (dir.IsOpened() && dir.HasSubDirs())

{

wxString name;

bContinue = dir.GetFirst(&name, wxEmptyString, wxDIR_DIRS);

while (bContinue)

{

nCount++;

wxString subdirPath = dirPath + wxFILE_SEP_PATH + name;

nCount += RecursivelyCountSubdirs(subdirPath);

bContinue = dir.GetNext(&name);

}

}

return nCount;

int nDirCount = 0,

ProgressDialog* pProgress = NULL)

{

bool bContinue;

wxDir dir(dirPath);

int nCount = 0;

if (dir.IsOpened())

{

if (dir.HasSubDirs())

{

wxString name;

bContinue = dir.GetFirst(&name, wxEmptyString, wxDIR_DIRS);

while (bContinue)

{

wxString subdirPath = dirPath + wxFILE_SEP_PATH + name;

nCount += RecursivelyRemoveEmptyDirs(subdirPath, nDirCount, pProgress);

bContinue = dir.GetNext(&name);

}

}

// Have to recheck dir.HasSubDirs() again, in case they all were deleted in recursive calls.

if (!dir.HasSubDirs() && !dir.HasFiles() && (dirPath.Right(5) != wxT("_data")))

{

// No subdirs or files. It's empty so DELETE it.

// Vaughan, 2010-07-07:

// Note that, per http://src.chromium.org/svn/trunk/src/base/file_util_win.cc, among others,

// "Some versions of Windows return ERROR_FILE_NOT_FOUND (0x2) when deleting

// an empty directory..." Supposedly fixed in Vista and up.

// I discovered this on WinXP. I tried several other Windows SDK functions (e.g., _rmdir

// and RemoveDirectory), and they all give same results.

// I noticed dirs get deleted in RecursivelyRemove, maybe because it doesn't

// consider whether the path is a directory or a file and wxRemoveFile()'s it first.

// Tried it here on WinXP, but no joy. Leave the code in case it works on other Win systems.

#ifdef __WXMSW__

::wxRemoveFile(dirPath);

#endif

::wxRmdir(dirPath);

}

nCount++; // Count dirPath in progress.

if (pProgress)

pProgress->Update(nCount, nDirCount);

}

return nCount;

int flags, const wxChar* message = NULL)

{

bool bFiles= (flags & kCleanFiles) != 0;

bool bDirs = (flags & kCleanDirs) != 0;

bool bDirsMustBeEmpty = (flags & kCleanDirsOnlyIfEmpty) != 0;

Maybe<ProgressDialog> progress{};

if (message)

progress.create( _("Progress"), message );

auto nn = filePathArray.size();

for (int i = 0; i < nn; i++) {

const wxChar *file = filePathArray[i].c_str();

if (bFiles)

::wxRemoveFile(file);

if (bDirs) {

// continue will go to the next item, and skip

// attempting to delete the directory.

if( bDirsMustBeEmpty ){

wxDir dir( file );

if( !dir.IsOpened() )

continue;

if( dir.HasFiles() )

continue;

if( dir.HasSubDirs() )

continue;

}

#ifdef __WXMSW__

if (!bFiles)

::wxRemoveFile(file); // See note above about wxRmdir sometimes incorrectly failing on Windows.

#endif

if (! ::wxRmdir(file) ) {

wxDir dir(file);

if(dir.IsOpened()) {

wxLogMessage(file + wxString(" still contains:"));

wxString name;

auto cont = dir.GetFirst(&name);

while ( cont ) {

wxLogMessage(file + wxString(wxFILE_SEP_PATH) + name );

cont = dir.GetNext(&name);

}

}

else

wxLogMessage(wxString("Can't enumerate directory ") + file);

}

}

if (progress)

progress->Update(i + bias, count);

}

{

wxLogDebug(wxT("DirManager: Created new instance."));

mLastBlockFileDestructionCount = BlockFile::gBlockFileDestructionCount;

// Seed the random number generator.

// this need not be strictly uniform or random, but it should give

// unclustered numbers

srand(time(NULL));

// Set up local temp subdir

// Previously, Audacity just named project temp directories "project0",

// "project1" and so on. But with the advent of recovery code, we need a

// unique name even after a crash. So we create a random project index

// and make sure it is not used already. This will not pose any performance

// penalties as long as the number of open Audacity projects is much

// lower than RAND_MAX.

do {

mytemp = globaltemp + wxFILE_SEP_PATH +

wxString::Format(wxT("project%d"), rand());

} while (wxDirExists(mytemp));

numDirManagers++;

projPath = wxT("");

projName = wxT("");

mLoadingTarget = NULL;

mLoadingTargetIdx = 0;

mMaxSamples = ~size_t(0);

// toplevel pool hash is fully populated to begin

{

// We can bypass the accessor function while initializing

auto &balanceInfo = mBalanceInfo;

auto &dirTopPool = balanceInfo.dirTopPool;

for(int i = 0; i < 256; ++i)

dirTopPool[i] = 0;

}

// Make sure there is plenty of space for temp files

wxLongLong freeSpace = 0;

if (wxGetDiskSpace(globaltemp, NULL, &freeSpace)) {

if (freeSpace < wxLongLong(wxLL(100 * 1048576))) {

ShowWarningDialog(NULL, wxT("DiskSpaceWarning"),

_("There is very little free disk space left on this volume.\nPlease select another temporary directory in Preferences."));

}

}

{

// with default flags (none) this does not clean the top directory, and may remove non-empty

// directories.

CleanDir(globaltemp, wxT("project*"), wxEmptyString, _("Cleaning up temporary files"));

const wxString &path,

const wxString &dirSpec,

const wxString &fileSpec,

const wxString &msg,

int flags)

{

if (dontDeleteTempFiles)

return; // do nothing

wxArrayString filePathArray, dirPathArray;

int countFiles =

RecursivelyEnumerate(path, filePathArray, dirSpec, fileSpec, true, false);

int countDirs =

RecursivelyEnumerate(path, dirPathArray, dirSpec, fileSpec, false, true);

// Subtract 1 because we don't want to DELETE the global temp directory,

// which this will find and list last.

if ((flags & kCleanTopDirToo)==0) {

// Remove the globaltemp itself from the array so that it is not deleted.

--countDirs;

dirPathArray.resize(countDirs);

}

auto count = countFiles + countDirs;

if (count == 0)

return;

RecursivelyRemove(filePathArray, count, 0, flags | kCleanFiles, msg);

RecursivelyRemove(dirPathArray, count, countFiles, flags | kCleanDirs, msg);

{

bool copying = false;

wxString oldPath = this->projPath;

wxString oldName = this->projName;

wxString oldFull = projFull;

wxString oldLoc = projFull;

if (oldLoc == wxT(""))

oldLoc = mytemp;

if (newProjPath == wxT(""))

newProjPath = ::wxGetCwd();

this->projPath = newProjPath;

this->projName = newProjName;

if (newProjPath.Last() == wxFILE_SEP_PATH)

this->projFull = newProjPath + newProjName;

else

this->projFull = newProjPath + wxFILE_SEP_PATH + newProjName;

wxString cleanupLoc1=oldLoc;

wxString cleanupLoc2=projFull;

if (bCreate) {

if (!wxDirExists(projFull))

if (!wxMkdir(projFull))

return false;

#ifdef __UNIX__

chmod(OSFILENAME(projFull), 0775);

#endif

#ifdef __WXMAC__

chmod(OSFILENAME(projFull), 0775);

#endif

} else {

if (!wxDirExists(projFull))

return false;

}

/* Move all files into this NEW directory. Files which are

int trueTotal = 0;

{

/*i18n-hint: This title appears on a dialog that indicates the progress in doing something.*/

ProgressDialog progress(_("Progress"),

_("Saving project data files"));

int total = mBlockFileHash.size();

BlockHash::iterator iter = mBlockFileHash.begin();

bool success = true;

int count = 0;

while ((iter != mBlockFileHash.end()) && success)

{

BlockFilePtr b = iter->second.lock();

if (b) {

// FIXME: TRAP_ERR

// JKC: The 'success' variable and recovery strategy looks

// broken/bogus to me. Would need to be using &= to catch

// failure in one of the copies/moves. Besides which,

// our temporary files are going to be deleted when we exit

// anyway, if saving from temporary to named project.

if (b->IsLocked())

success = CopyToNewProjectDirectory( &*b ), copying = true;

else{

success = MoveToNewProjectDirectory( &*b );

}

progress.Update(count, total);

count++;

}

++iter;

}

// in case there are any nulls

trueTotal = count;

if (!success) {

// If the move failed, we try to move/copy as many files

// back as possible so that no damage was done. (No sense

// in checking for errors this time around - there's nothing

// that could be done about it.)

// Likely causes: directory was not writeable, disk was full

projFull = oldLoc;

BlockHash::iterator iter = mBlockFileHash.begin();

while (iter != mBlockFileHash.end())

{

BlockFilePtr b = iter->second.lock();

if (b) {

MoveToNewProjectDirectory(&*b);

if (count >= 0)

progress.Update(count, total);

count--;

}

++iter;

}

this->projFull = oldFull;

this->projPath = oldPath;

this->projName = oldName;

return false;

}

}

// Some subtlety; SetProject is used both to move a temp project

// into a permanent home as well as just set up path variables when

// loading a project; in this latter case, the movement code does

// nothing because SetProject is called before there are any

// blockfiles. Cleanup code trigger is the same

// Do the cleanup of the temporary directory only if not saving-as, which we

// detect by having done copies rather than moves.

if (!copying && trueTotal > 0) {

// Clean up after ourselves; boldly remove all files and directories

// in the tree. (Unlike what the earlier version of this comment said.)

// Because this is a relocation of the project, not the case of closing

// a persistent project.

// You may think the loops above guarantee that all files we put in the

// folders have been moved away already, but:

// to fix bug1567 on Mac, we need to find the extraneous .DS_Store files

// that we didn't put there, but that Finder may insert into the folders,

// and mercilessly remove them, in addition to removing the directories.

CleanDir(

cleanupLoc1,

wxEmptyString, // EmptyString => ALL directories.

// If the next line were wxEmptyString, ALL files would be removed.

".DS_Store", // Other project files should already have been removed.

_("Cleaning up cache directories"),

kCleanTopDirToo);

//This destroys the empty dirs of the OD block files, which are yet to come.

//Dont know if this will make the project dirty, but I doubt it. (mchinen)

// count += RecursivelyEnumerate(cleanupLoc2, dirlist, wxEmptyString, false, true);

}

return true;

{

wxLongLong freeSpace = -1;

wxFileName path;

path.SetPath(projPath.IsEmpty() ? mytemp : projPath);

// Use the parent directory if the project directory hasn't yet been created

if (!path.DirExists())

{

path.RemoveLastDir();

}

if (!wxGetDiskSpace(path.GetFullPath(), NULL, &freeSpace))

{

freeSpace = -1;

}

return freeSpace;

wxFileNameWrapper dir;

dir.AssignDir(GetDataFilesDir());

if(value.GetChar(0)==wxT('d')){

// this file is located in a subdirectory tree

int location=value.Find(wxT('b'));

wxString subdir=value.Mid(0,location);

dir.AppendDir(subdir);

if(!dir.DirExists())

dir.Mkdir();

}

if(value.GetChar(0)==wxT('e')){

// this file is located in a NEW style two-deep subdirectory tree

wxString topdir=value.Mid(0,3);

wxString middir=wxT("d");

middir.Append(value.Mid(3,2));

dir.AppendDir(topdir);

dir.AppendDir(middir);

if(!dir.DirExists() && !dir.Mkdir(0777,wxPATH_MKDIR_FULL))

{ // need braces to avoid compiler warning about ambiguous else, see the macro

wxLogSysError(_("mkdir in DirManager::MakeBlockFilePath failed."));

}

}

return dir;

const wxString &value,

bool diskcheck)

{

wxFileNameWrapper dir{ MakeBlockFilePath(value) };

if(diskcheck){

// verify that there's no possible collision on disk. If there

// is, log the problem and return FALSE so that MakeBlockFileName

// can try again

wxDir checkit(dir.GetFullPath());

if(!checkit.IsOpened()) return FALSE;

// this code is only valid if 'value' has no extention; that

// means, effectively, AssignFile may be called with 'diskcheck'

// set to true only if called from MakeFileBlockName().

wxString filespec;

filespec.Printf(wxT("%s.*"),value.c_str());

if(checkit.HasFiles(filespec)){

// collision with on-disk state!

wxString collision;

checkit.GetFirst(&collision,filespec);

wxLogWarning(_("Audacity found an orphan block file: %s. \nPlease consider saving and reloading the project to perform a complete project check."),

collision.c_str());

return FALSE;

}

}

fileName.Assign(dir.GetFullPath(),value);

return fileName.IsOk();

{

if(x<48U)return 0;

if(x<58U)return x-48U;

if(x<65U)return 10U;

if(x<71U)return x-55U;

if(x<97U)return 10U;

if(x<103U)return x-87U;

return 15U;

{

// enter the midlevel directory if it doesn't exist

auto &balanceInfo = GetBalanceInfo();

auto &dirMidPool = balanceInfo.dirMidPool;

auto &dirMidFull = balanceInfo.dirMidFull;

auto &dirTopPool = balanceInfo.dirTopPool;

auto &dirTopFull = balanceInfo.dirTopFull;

if(dirMidPool.find(midkey) == dirMidPool.end() &&

dirMidFull.find(midkey) == dirMidFull.end()){

dirMidPool[midkey]=0;

// increment toplevel directory fill

dirTopPool[topnum]++;

if(dirTopPool[topnum]>=256){

// this toplevel is now full; move it to the full hash

dirTopPool.erase(topnum);

dirTopFull[topnum]=256;

}

return 1;

}

return 0;

{

auto &balanceInfo = GetBalanceInfo();

auto &dirMidPool = balanceInfo.dirMidPool;

auto &dirMidFull = balanceInfo.dirMidFull;

// increment the midlevel directory usage information

if(dirMidPool.find(midkey) != dirMidPool.end()){

dirMidPool[midkey]++;

if(dirMidPool[midkey]>=256){

// this middir is now full; move it to the full hash

dirMidPool.erase(midkey);

dirMidFull[midkey]=256;

}

}else{

// this case only triggers in absurdly large projects; we still

// need to track directory fill even if we're over 256/256/256

dirMidPool[midkey]++;

}

{

const wxChar *s=file.c_str();

if(s[0]==wxT('e')){

// this is one of the modern two-deep managed files

// convert filename to keys

unsigned int topnum = (hexchar_to_int(s[1]) << 4) |

hexchar_to_int(s[2]);

unsigned int midnum = (hexchar_to_int(s[3]) << 4) |

hexchar_to_int(s[4]);

unsigned int midkey=topnum<<8|midnum;

BalanceMidAdd(topnum,midkey);

BalanceFileAdd(midkey);

}

{

// Before returning the map,

// see whether any block files have disappeared,

// and if so update

auto count = BlockFile::gBlockFileDestructionCount;

if ( mLastBlockFileDestructionCount != count ) {

auto it = mBlockFileHash.begin(), end = mBlockFileHash.end();

while (it != end)

{

BlockFilePtr ptr { it->second.lock() };

if (!ptr) {

auto name = it->first;

mBlockFileHash.erase( it++ );

BalanceInfoDel( name );

}

else

++it;

}

}

mLastBlockFileDestructionCount = count;

return mBalanceInfo;

{

// do not use GetBalanceInfo(),

// rather this function will be called from there.

auto &balanceInfo = mBalanceInfo;

auto &dirMidPool = balanceInfo.dirMidPool;

auto &dirMidFull = balanceInfo.dirMidFull;

auto &dirTopPool = balanceInfo.dirTopPool;

auto &dirTopFull = balanceInfo.dirTopFull;

const wxChar *s=file.c_str();

if(s[0]==wxT('e')){

// this is one of the modern two-deep managed files

unsigned int topnum = (hexchar_to_int(s[1]) << 4) |

hexchar_to_int(s[2]);

unsigned int midnum = (hexchar_to_int(s[3]) << 4) |

hexchar_to_int(s[4]);

unsigned int midkey=topnum<<8|midnum;

// look for midkey in the mid pool

if(dirMidFull.find(midkey) != dirMidFull.end()){

// in the full pool

if(--dirMidFull[midkey]<256){

// move out of full into available

dirMidPool[midkey]=dirMidFull[midkey];

dirMidFull.erase(midkey);

}

}else{

if(--dirMidPool[midkey]<1){

// erasing the key here is OK; we have provision to add it

// back if its needed (unlike the dirTopPool hash)

dirMidPool.erase(midkey);

// DELETE the actual directory

wxString dir=(projFull != wxT("")? projFull: mytemp);

dir += wxFILE_SEP_PATH;

dir += file.Mid(0,3);

dir += wxFILE_SEP_PATH;

dir += wxT("d");

dir += file.Mid(3,2);

wxFileName::Rmdir(dir);

// also need to remove from toplevel

if(dirTopFull.find(topnum) != dirTopFull.end()){

// in the full pool

if(--dirTopFull[topnum]<256){

// move out of full into available

dirTopPool[topnum]=dirTopFull[topnum];

dirTopFull.erase(topnum);

}

}else{

if(--dirTopPool[topnum]<1){

// do *not* erase the hash entry from dirTopPool

// *do* DELETE the actual directory

wxString dir=(projFull != wxT("")? projFull: mytemp);

dir += wxFILE_SEP_PATH;

dir += file.Mid(0,3);

wxFileName::Rmdir(dir);

}

}

}

}

}

{

auto &balanceInfo = GetBalanceInfo();

auto &dirMidPool = balanceInfo.dirMidPool;

auto &dirTopPool = balanceInfo.dirTopPool;

auto &dirTopFull = balanceInfo.dirTopFull;

wxFileNameWrapper ret;

wxString baseFileName;

unsigned int filenum,midnum,topnum,midkey;

while(1){

/* blockfiles are divided up into heirarchical directories.

filenum=0;

midnum=0;

topnum=0;

// first action: if there is no available two-level directory in

// the available pool, try to make one

if(dirMidPool.empty()){

// is there a toplevel directory with space for a NEW subdir?

if(!dirTopPool.empty()){

// there's still a toplevel with room for a subdir

DirHash::iterator iter = dirTopPool.begin();

int newcount = 0;

topnum = iter->first;

// search for unused midlevels; linear search adequate

// add 32 NEW topnum/midnum dirs full of prospective filenames to midpool

for(midnum=0;midnum<256;midnum++){

midkey=(topnum<<8)+midnum;

if(BalanceMidAdd(topnum,midkey)){

newcount++;

if(newcount>=32)break;

}

}

if(dirMidPool.empty()){

// all the midlevels in this toplevel are in use yet the

// toplevel claims some are free; this implies multiple

// internal logic faults, but simply giving up and going

// into an infinite loop isn't acceptible. Just in case,

// for some reason, we get here, dynamite this toplevel so

// we don't just fail.

// this is 'wrong', but the best we can do given that

// something else is also wrong. It will contain the

// problem so we can keep going without worry.

dirTopPool.erase(topnum);

dirTopFull[topnum]=256;

}

continue;

}

}

if(dirMidPool.empty()){

// still empty, thus an absurdly large project; all dirs are

// full to 256/256/256; keep working, but fall back to 'big

// filenames' and randomized placement

filenum = rand();

midnum = (int)(256.*rand()/(RAND_MAX+1.));

topnum = (int)(256.*rand()/(RAND_MAX+1.));

midkey=(topnum<<8)+midnum;

}else{

DirHash::iterator iter = dirMidPool.begin();

midkey = iter->first;

// split the retrieved 16 bit directory key into two 8 bit numbers

topnum = midkey >> 8;

midnum = midkey & 0xff;

filenum = (int)(4096.*rand()/(RAND_MAX+1.));

}

baseFileName.Printf(wxT("e%02x%02x%03x"),topnum,midnum,filenum);

if (!ContainsBlockFile(baseFileName)) {

// not in the hash, good.