ProjectFileIO Class Reference

Object associated with a project that manages reading and writing of Audacity project file formats, and autosave. More...

#include <ProjectFileIO.h>

Inheritance diagram for ProjectFileIO:

Collaboration diagram for ProjectFileIO:

Classes
class	BackupProject

Public Types
using	ExecCB = std::function< int(int cols, char **vals, char **names)>
Public Types inherited from Observer::Publisher< ProjectFileIOMessage >
using	message_type = ProjectFileIOMessage
using	CallbackReturn = std::conditional_t< true, void, bool >
using	Callback = std::function< CallbackReturn(const ProjectFileIOMessage &) >
	Type of functions that can be connected to the Publisher. More...

Public Member Functions
	ProjectFileIO (AudacityProject &project)
	ProjectFileIO (const ProjectFileIO &)=delete
ProjectFileIO &	operator= (const ProjectFileIO &)=delete
	~ProjectFileIO ()
const wxString &	GetProjectTitle () const
void	SetProjectTitle (int number=-1)
const FilePath &	GetFileName () const
void	SetFileName (const FilePath &fileName)
bool	IsModified () const
bool	IsTemporary () const
bool	IsRecovered () const
bool	AutoSave (bool recording=false)
bool	AutoSaveDelete (sqlite3 *db=nullptr)
bool	OpenProject ()
bool	CloseProject ()
bool	ReopenProject ()
bool	LoadProject (const FilePath &fileName, bool ignoreAutosave)
bool	UpdateSaved (const TrackList *tracks=nullptr)
bool	SaveProject (const FilePath &fileName, const TrackList *lastSaved)
bool	SaveCopy (const FilePath &fileName)
wxLongLong	GetFreeDiskSpace () const
int64_t	GetBlockUsage (SampleBlockID blockid)
int64_t	GetCurrentUsage (const std::vector< const TrackList * > &trackLists) const
int64_t	GetTotalUsage ()
void	ShowError (const BasicUI::WindowPlacement &placement, const TranslatableString &dlogTitle, const TranslatableString &message, const wxString &helpPage)
	Displays an error dialog with a button that offers help. More...
const TranslatableString &	GetLastError () const
const TranslatableString &	GetLibraryError () const
int	GetLastErrorCode () const
const wxString &	GetLastLog () const
void	SetBypass ()
void	Compact (const std::vector< const TrackList * > &tracks, bool force=false)
bool	WasCompacted ()
bool	HadUnused ()
bool	DeleteBlocks (const BlockIDs &blockids, bool complement)
bool	HasConnection () const
	Return true if a connection is now open. More...
DBConnection &	GetConnection ()
	Return a reference to a connection, creating it as needed on demand; throw on failure. More...
wxString	GenerateDoc ()
	Return a strings representation of the active project XML doc. More...
Public Member Functions inherited from ClientData::Base
virtual	~Base ()
Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()
virtual	~XMLTagHandler ()
virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0
virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))
virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))
virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0
void	ReadXMLEndTag (const char *tag)
void	ReadXMLContent (const char *s, int len)
XMLTagHandler *	ReadXMLChild (const char *tag)
Public Member Functions inherited from Observer::Publisher< ProjectFileIOMessage >
	Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
	Constructor supporting type-erased custom allocation/deletion. More...
	Publisher (Publisher &&)=default
Publisher &	operator= (Publisher &&)=default
Subscription	Subscribe (Callback callback)
	Connect a callback to the Publisher; later-connected are called earlier. More...
Subscription	Subscribe (Object &obj, Return(Object::*callback)(Args...))
	Overload of Subscribe takes an object and pointer-to-member-function. More...

Static Public Member Functions
static bool	InitializeSQL ()
static ProjectFileIO &	Get (AudacityProject &project)
static const ProjectFileIO &	Get (const AudacityProject &project)
static int64_t	GetDiskUsage (DBConnection &conn, SampleBlockID blockid)
static bool	RemoveProject (const FilePath &filename)
	Remove any files associated with a project at given path; return true if successful. More...

Private Member Functions
bool	RenameOrWarn (const FilePath &src, const FilePath &dst)
	Rename a file or put up appropriate warning message. More...
bool	MoveProject (const FilePath &src, const FilePath &dst)
void	OnCheckpointFailure ()
void	WriteXMLHeader (XMLWriter &xmlFile) const
void	WriteXML (XMLWriter &xmlFile, bool recording=false, const TrackList *tracks=nullptr)
bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override
XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override
void	UpdatePrefs () override
int	Exec (const char *query, const ExecCB &callback, bool silent=false)
sqlite3 *	DB ()
bool	OpenConnection (FilePath fileName={})
bool	CloseConnection ()
void	SaveConnection ()
void	DiscardConnection ()
void	RestoreConnection ()
void	UseConnection (Connection &&conn, const FilePath &filePath)
bool	Query (const char *sql, const ExecCB &callback, bool silent=false)
bool	GetValue (const char *sql, wxString &value, bool silent=false)
bool	GetValue (const char *sql, int64_t &value, bool silent=false)
bool	CheckVersion ()
bool	InstallSchema (sqlite3 *db, const char *schema="main")
bool	WriteDoc (const char *table, const ProjectSerializer &autosave, const char *schema="main")
bool	CopyTo (const FilePath &destpath, const TranslatableString &msg, bool isTemporary, bool prune=false, const std::vector< const TrackList * > &tracks={})
void	SetError (const TranslatableString &msg, const TranslatableString &libraryError={}, int errorCode={})
	Just set stored errors. More...
void	SetDBError (const TranslatableString &msg, const TranslatableString &libraryError={}, int errorCode=-1)
	Set stored errors and write to log; and default libraryError to what database library reports. More...
bool	ShouldCompact (const std::vector< const TrackList * > &tracks)
Connection &	CurrConn ()
Private Member Functions inherited from PrefsListener
	PrefsListener ()
virtual	~PrefsListener ()
virtual void	UpdatePrefs ()=0
virtual void	UpdateSelectedPrefs (int id)

Static Private Member Functions
static const std::vector< wxString > &	AuxiliaryFileSuffixes ()
static FilePath	SafetyFileName (const FilePath &src)
	Generate a name for short-lived backup project files from an existing project. More...
static void	InSet (sqlite3_context *context, int argc, sqlite3_value **argv)
static unsigned int	get2 (const unsigned char *ptr)
static unsigned int	get4 (const unsigned char *ptr)
static int	get_varint (const unsigned char *ptr, int64_t *out)
Static Private Member Functions inherited from PrefsListener
static void	Broadcast (int id=0)
	Call this static function to notify all PrefsListener objects. More...

Private Attributes
AudacityProject &	mProject
wxString	mTitle
std::shared_ptr< DBConnectionErrors >	mpErrors
FilePath	mFileName
bool	mRecovered
bool	mModified
bool	mTemporary
bool	mWasCompacted
bool	mHadUnused
Connection	mPrevConn
FilePath	mPrevFileName
bool	mPrevTemporary

Additional Inherited Members
Static Public Attributes inherited from Observer::Publisher< ProjectFileIOMessage >
static constexpr bool	notifies_all
Protected Member Functions inherited from Observer::Publisher< ProjectFileIOMessage >
CallbackReturn	Publish (const ProjectFileIOMessage &message)
	Send a message to connected callbacks. More...

Detailed Description

Object associated with a project that manages reading and writing of Audacity project file formats, and autosave.

Definition at line 58 of file ProjectFileIO.h.

Member Typedef Documentation

ExecCB

using ProjectFileIO::ExecCB = std::function<int(int cols, char **vals, char **names)>

Definition at line 197 of file ProjectFileIO.h.

Constructor & Destructor Documentation

ProjectFileIO() [1/2]

ProjectFileIO::ProjectFileIO ( AudacityProject &  project )

explicit

Definition at line 444 of file ProjectFileIO.cpp.

   : mProject{ project }
   , mpErrors{ std::make_shared<DBConnectionErrors>() }
{
   mPrevConn = nullptr;
 
   mRecovered = false;
   mModified = false;
   mTemporary = true;
 
   SetProjectTitle();
 
   // Make sure there is plenty of space for Sqlite files
   wxLongLong freeSpace = 0;
 
   auto path = TempDirectory::TempDir();
   if (wxGetDiskSpace(path, NULL, &freeSpace)) {
      if (freeSpace < wxLongLong(wxLL(100 * 1048576))) {
         auto volume = FileNames::AbbreviatePath( path );
         /* i18n-hint: %s will be replaced by the drive letter (on Windows) */
         BasicUI::ShowErrorDialog( {},
            XO("Warning"),
            XO("There is very little free disk space left on %s\n"
               "Please select a bigger temporary directory location in\n"
               "Directories Preferences.").Format( volume ),
            "Error:_Disk_full_or_not_writable"
            );
      }
   }
}

References FileNames::AbbreviatePath(), mModified, mPrevConn, mRecovered, mTemporary, SetProjectTitle(), BasicUI::ShowErrorDialog(), TempDirectory::TempDir(), and XO().

Here is the call graph for this function:

ProjectFileIO() [2/2]

ProjectFileIO::ProjectFileIO ( const ProjectFileIO &  )

delete

~ProjectFileIO()

ProjectFileIO::~ProjectFileIO

(

)

Definition at line 475 of file ProjectFileIO.cpp.

{
}

Member Function Documentation

AutoSave()

bool ProjectFileIO::AutoSave

(

bool

recording = false

)

Definition at line 1801 of file ProjectFileIO.cpp.

{
   ProjectSerializer autosave;
   WriteXMLHeader(autosave);
   WriteXML(autosave, recording);
 
   if (WriteDoc("autosave", autosave))
   {
      mModified = true;
      return true;
   }
 
   return false;
}

References mModified, WriteDoc(), WriteXML(), and WriteXMLHeader().

Here is the call graph for this function:

AutoSaveDelete()

bool ProjectFileIO::AutoSaveDelete

(

sqlite3 *

db = nullptr

)

Definition at line 1816 of file ProjectFileIO.cpp.

{
   int rc;
 
   if (!db)
   {
      db = DB();
   }
 
   rc = sqlite3_exec(db, "DELETE FROM autosave;", nullptr, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::AutoSaveDelete");
 
      SetDBError(
         XO("Failed to remove the autosave information from the project file.")
      );
      return false;
   }
 
   mModified = false;
 
   return true;
}

References ADD_EXCEPTION_CONTEXT, DB(), mModified, SetDBError(), and XO().

Referenced by Compact(), SaveProject(), and UpdateSaved().

Here is the call graph for this function:

Here is the caller graph for this function:

AuxiliaryFileSuffixes()

const std::vector< wxString > & ProjectFileIO::AuxiliaryFileSuffixes ( )

staticprivate

Strings like -wal that may be appended to main project name to get other files created by the database system

Definition at line 1255 of file ProjectFileIO.cpp.

{
   static const std::vector<wxString> strings {
      "-wal",
#ifndef NO_SHM
      "-shm",
#endif
   };
   return strings;
}

Referenced by MoveProject(), RemoveProject(), SafetyFileName(), and ProjectFileIO::BackupProject::~BackupProject().

Here is the caller graph for this function:

CheckVersion()

bool ProjectFileIO::CheckVersion ( )

private

Definition at line 764 of file ProjectFileIO.cpp.

{
   auto db = DB();
   int rc;
 
   // Install our schema if this is an empty DB
   wxString result;
   if (!GetValue("SELECT Count(*) FROM sqlite_master WHERE type='table';", result))
   {
      // Bug 2718 workaround for a better error message:
      // If at this point we get SQLITE_CANTOPEN, then the directory is read-only
      if (GetLastErrorCode() == SQLITE_CANTOPEN)
      {
          SetError(
              /* i18n-hint: An error message. */
              XO("Project is in a read only directory\n(Unable to create the required temporary files)"),
              GetLibraryError()
          );
      }
 
      return false;
   }
 
   // If the return count is zero, then there are no tables defined, so this
   // must be a new project file.
   if (wxStrtol<char **>(result, nullptr, 10) == 0)
   {
      return InstallSchema(db);
   }
 
   // Check for our application ID
   if (!GetValue("PRAGMA application_ID;", result))
   {
      return false;
   }
 
   // It's a database that SQLite recognizes, but it's not one of ours
   if (wxStrtoul<char **>(result, nullptr, 10) != ProjectFileID)
   {
      SetError(XO("This is not an Audacity project file"));
      return false;
   }
 
   // Get the project file version
   if (!GetValue("PRAGMA user_version;", result))
   {
      return false;
   }
 
   const ProjectFormatVersion version =
      ProjectFormatVersion::FromPacked(wxStrtoul<char**>(result, nullptr, 10));
 
   // Project file version is higher than ours. We will refuse to
   // process it since we can't trust anything about it.
   if (SupportedProjectFormatVersion < version)
   {
      SetError(
         XO("This project was created with a newer version of Audacity.\n\nYou will need to upgrade to open it.")
      );
      return false;
   }
   
   return true;
}

References DB(), ProjectFormatVersion::FromPacked(), GetLastErrorCode(), GetLibraryError(), GetValue(), InstallSchema(), ProjectFileID, SetError(), SupportedProjectFormatVersion, and XO().

Referenced by OpenConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

CloseConnection()

bool ProjectFileIO::CloseConnection ( )

private

Definition at line 582 of file ProjectFileIO.cpp.

{
   auto &curConn = CurrConn();
   if (!curConn)
      return false;
 
   if (!curConn->Close())
   {
      return false;
   }
   curConn.reset();
 
   SetFileName({});
 
   return true;
}

References CurrConn(), and SetFileName().

Referenced by CloseProject(), Compact(), OpenConnection(), ReopenProject(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

CloseProject()

bool ProjectFileIO::CloseProject

(

)

Definition at line 2366 of file ProjectFileIO.cpp.

{
   auto &currConn = CurrConn();
   if (!currConn)
   {
      wxLogDebug("Closing project with no database connection");
      return true;
   }
 
   // Save the filename since CloseConnection() will clear it
   wxString filename = mFileName;
 
   // Not much we can do if this fails.  The user will simply get
   // the recovery dialog upon next restart.
   if (CloseConnection())
   {
      // If this is a temporary project, we no longer want to keep the
      // project file.
      if (IsTemporary())
      {
         // This is just a safety check.
         wxFileName temp(TempDirectory::TempDir(), wxT(""));
         wxFileName file(filename);
         file.SetFullName(wxT(""));
         if (file == temp)
            RemoveProject(filename);
      }
   }
 
   return true;
}

References CloseConnection(), CurrConn(), IsTemporary(), mFileName, RemoveProject(), TempDirectory::TempDir(), and wxT().

Referenced by SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

Compact()

void ProjectFileIO::Compact	(	const std::vector< const TrackList * > &	tracks,
		bool	force = false
	)

Definition at line 1431 of file ProjectFileIO.cpp.

{
   // Haven't compacted yet
   mWasCompacted = false;
 
   // Assume we have unused blocks until we find out otherwise. That way cleanup
   // at project close time will still occur.
   mHadUnused = true;
 
   // If forcing compaction, bypass inspection.
   if (!force)
   {
      // Don't compact if this is a temporary project or if it's determined there are not
      // enough unused blocks to make it worthwhile.
      if (IsTemporary() || !ShouldCompact(tracks))
      {
         // Delete the AutoSave doc it if exists
         if (IsModified())
         {
            // PRL:  not clear what to do if the following fails, but the worst should
            // be, the project may reopen in its present state as a recovery file, not
            // at the last saved state.
            // REVIEW: Could the autosave file be corrupt though at that point, and so 
            // prevent recovery?
            // LLL: I believe Paul is correct since it's deleted with a single SQLite
            // transaction. The next time the file opens will just invoke recovery.
            (void) AutoSaveDelete();
         }
 
         return;
      }
   }
 
   wxString origName = mFileName;
   wxString backName = origName + "_compact_back";
   wxString tempName = origName + "_compact_temp";
 
   // Copy the original database to a new database. Only prune sample blocks if
   // we have a tracklist.
   // REVIEW: Compact can fail on the CopyTo with no error messages.  That's OK?
   // LLL: We could display an error message or just ignore the failure and allow
   // the file to be compacted the next time it's saved.
   if (CopyTo(tempName, XO("Compacting project"), IsTemporary(), !tracks.empty(), tracks))
   {
      // Must close the database to rename it
      if (CloseConnection())
      {
         // Only use the new file if it is actually smaller than the original.
         //
         // If the original file doesn't have anything to compact (original and new
         // are basically identical), the file could grow by a few pages because of
         // differences in how SQLite constructs the b-tree.
         //
         // In this case, just toss the new file and continue to use the original.
         //
         // Also, do this after closing the connection so that the -wal file
         // gets cleaned up.
         if (wxFileName::GetSize(tempName) < wxFileName::GetSize(origName))
         {
            // Rename the original to backup
            if (wxRenameFile(origName, backName))
            {
               // Rename the temporary to original
               if (wxRenameFile(tempName, origName))
               {
                  // Open the newly compacted original file
                  if (OpenConnection(origName))
                  {
                     // Remove the old original file
                     if (!wxRemoveFile(backName))
                     {
                        // Just log the error, nothing can be done to correct it
                        // and WX should have logged another message showing the
                        // system error code.
                        wxLogWarning(wxT("Compaction failed to delete backup %s"), backName);
                     }
 
                     // Remember that we compacted
                     mWasCompacted = true;
 
                     return;
                  }
                  else
                  {
                     wxLogWarning(wxT("Compaction failed to open new project %s"), origName);
                  }
 
                  if (!wxRenameFile(origName, tempName))
                  {
                     wxLogWarning(wxT("Compaction failed to rename original %s to temp %s"),
                                  origName, tempName);
                  }
               }
               else
               {
                  wxLogWarning(wxT("Compaction failed to rename temp %s to orig %s"),
                                 origName, tempName);
               }
 
               if (!wxRenameFile(backName, origName))
               {
                  wxLogWarning(wxT("Compaction failed to rename back %s to orig %s"),
                               backName, origName);
               }
            }
            else
            {
               wxLogWarning(wxT("Compaction failed to rename orig %s to back %s"),
                              backName, origName);
            }
         }
 
         if (!OpenConnection(origName))
         {
            wxLogWarning(wxT("Compaction failed to reopen %s"), origName);
         }
      }
 
      // Did not achieve any real compaction
      // RemoveProject not needed for what was an attached database
      if (!wxRemoveFile(tempName))
      {
         // Just log the error, nothing can be done to correct it
         // and WX should have logged another message showing the
         // system error code.
         wxLogWarning(wxT("Failed to delete temporary file...ignoring"));
      }
   }
 
   return;
}

References AutoSaveDelete(), CloseConnection(), CopyTo(), IsModified(), IsTemporary(), mFileName, mHadUnused, mWasCompacted, OpenConnection(), ShouldCompact(), wxT(), and XO().

Referenced by SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

CopyTo()

bool ProjectFileIO::CopyTo ( const FilePath &  destpath, const TranslatableString &  msg, bool  isTemporary, bool  prune = false, const std::vector< const TrackList * > &  tracks = {}  )

private

Parameters

tracks

First track list (or if none, then the project's track list) are tracks to write into document blob; That list, plus any others, contain tracks whose sample blocks must be kept

Definition at line 939 of file ProjectFileIO.cpp.

{
   using namespace BasicUI;
 
   auto pConn = CurrConn().get();
   if (!pConn)
      return false;
 
   // Get access to the active tracklist
   auto pProject = &mProject;
 
   SampleBlockIDSet blockids;
 
   // Collect all active blockids
   if (prune)
   {
      for (auto trackList : tracks)
         if (trackList)
            InspectBlocks( *trackList, {}, &blockids );
   }
   // Collect ALL blockids
   else
   {
      auto cb = [&blockids](int cols, char **vals, char **){
         SampleBlockID blockid;
         wxString{ vals[0] }.ToLongLong(&blockid);
         blockids.insert(blockid);
         return 0;
      };
 
      if (!Query("SELECT blockid FROM sampleblocks;", cb))
      {
         // Error message already captured.
         return false;
      }
   }
 
   // Create the project doc
   ProjectSerializer doc;
   WriteXMLHeader(doc);
   WriteXML(doc, false, tracks.empty() ? nullptr : tracks[0]);
 
   auto db = DB();
   Connection destConn = nullptr;
   bool success = false;
   int rc = SQLITE_OK;
   ProgressResult res = ProgressResult::Success;
 
   // Cleanup in case things go awry
   auto cleanup = finally([&]
   {
      if (!success)
      {
         if (destConn)
         {
            destConn->Close();
            destConn = nullptr;
         }
 
         // Rollback transaction in case one was active.
         // If this fails (probably due to memory or disk space), the transaction will
         // (presumably) still be active, so further updates to the project file will
         // fail as well. Not really much we can do about it except tell the user.
         auto result = sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
 
         // Only capture the error if there wasn't a previous error
         if (result != SQLITE_OK && (rc == SQLITE_DONE || rc == SQLITE_OK))
         {
            ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
            ADD_EXCEPTION_CONTEXT(
               "sqlite3.context", "ProjectGileIO::CopyTo.cleanup");
 
            SetDBError(
               XO("Failed to rollback transaction during import")
            );
         }
 
         // And detach the outbound DB in case (if it's attached). Don't check for
         // errors since it may not be attached. But, if it is and the DETACH fails,
         // subsequent CopyTo() actions will fail until Audacity is relaunched.
         sqlite3_exec(db, "DETACH DATABASE outbound;", nullptr, nullptr, nullptr);
 
         // RemoveProject not necessary to clean up attached database
         wxRemoveFile(destpath);
      }
   });
 
   // Attach the destination database 
   wxString sql;
   wxString dbName = destpath;
   // Bug 2793: Quotes in name need escaping for sqlite3.
   dbName.Replace( "'", "''");
   sql.Printf("ATTACH DATABASE '%s' AS outbound;", dbName.ToUTF8());
 
   rc = sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      SetDBError(
         XO("Unable to attach destination database")
      );
      return false;
   }
 
   // Ensure attached DB connection gets configured
   //
   // NOTE:  Between the above attach and setting the mode here, a normal DELETE
   //        mode journal will be used and will briefly appear in the filesystem.
   if ( pConn->FastMode("outbound") != SQLITE_OK)
   {
      SetDBError(
         XO("Unable to switch to fast journaling mode")
      );
 
      return false;
   }
 
   // Install our schema into the new database
   if (!InstallSchema(db, "outbound"))
   {
      // Message already set
      return false;
   }
 
   {
      // Ensure statement gets cleaned up
      sqlite3_stmt *stmt = nullptr;
      auto cleanup = finally([&]
      {
         if (stmt)
         {
            // No need to check return code
            sqlite3_finalize(stmt);
         }
      });
 
      // Prepare the statement only once
      rc = sqlite3_prepare_v2(db,
                              "INSERT INTO outbound.sampleblocks"
                              "  SELECT * FROM main.sampleblocks"
                              "  WHERE blockid = ?;",
                              -1,
                              &stmt,
                              nullptr);
      if (rc != SQLITE_OK)
      {
         ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
         ADD_EXCEPTION_CONTEXT(
            "sqlite3.context", "ProjectGileIO::CopyTo.prepare");
 
         SetDBError(
            XO("Unable to prepare project file command:\n\n%s").Format(sql)
         );
         return false;
      }
 
      /* i18n-hint: This title appears on a dialog that indicates the progress
         in doing something.*/
      auto progress =
         BasicUI::MakeProgress(XO("Progress"), msg, ProgressShowCancel);
      ProgressResult result = ProgressResult::Success;
 
      wxLongLong_t count = 0;
      wxLongLong_t total = blockids.size();
 
      // Start a transaction.  Since we're running without a journal,
      // this really doesn't provide rollback.  It just prevents SQLite
      // from auto committing after each step through the loop.
      //
      // Also note that we will have an open transaction if we fail
      // while copying the blocks. This is fine since we're just going
      // to delete the database anyway.
      sqlite3_exec(db, "BEGIN;", nullptr, nullptr, nullptr);
 
      // Copy sample blocks from the main DB to the outbound DB
      for (auto blockid : blockids)
      {
         // Bind statement parameters
         rc = sqlite3_bind_int64(stmt, 1, blockid);
         if (rc != SQLITE_OK)
         {
            ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
            ADD_EXCEPTION_CONTEXT(
               "sqlite3.context", "ProjectGileIO::CopyTo.bind");
 
            SetDBError(
               XO("Failed to bind SQL parameter")
            );
 
            return false;
         }
 
         // Process it
         rc = sqlite3_step(stmt);
         if (rc != SQLITE_DONE)
         {
            ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
            ADD_EXCEPTION_CONTEXT(
               "sqlite3.context", "ProjectGileIO::CopyTo.step");
 
            SetDBError(
               XO("Failed to update the project file.\nThe following command failed:\n\n%s").Format(sql)
            );
            return false;
         }
 
         // Reset statement to beginning
         if (sqlite3_reset(stmt) != SQLITE_OK)
         {
            ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
            ADD_EXCEPTION_CONTEXT(
               "sqlite3.context", "ProjectGileIO::CopyTo.reset");
 
            THROW_INCONSISTENCY_EXCEPTION;
         }
 
         result = progress->Poll(++count, total);
         if (result != ProgressResult::Success)
         {
            // Note that we're not setting success, so the finally
            // block above will take care of cleaning up
            return false;
         }
      }
 
      // Write the doc.
      //
      // If we're compacting a temporary project (user initiated from the File
      // menu), then write the doc to the "autosave" table since temporary
      // projects do not have a "project" doc.
      if (!WriteDoc(isTemporary ? "autosave" : "project", doc, "outbound"))
      {
         return false;
      }
 
      // See BEGIN above...
      sqlite3_exec(db, "COMMIT;", nullptr, nullptr, nullptr);
   }
 
   // Detach the destination database
   rc = sqlite3_exec(db, "DETACH DATABASE outbound;", nullptr, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::CopyTo::detach");
 
      SetDBError(
         XO("Destination project could not be detached")
      );
 
      return false;
   }
 
   // Tell cleanup everything is good to go
   success = true;
 
   return true;
}

References ADD_EXCEPTION_CONTEXT, CurrConn(), DB(), InspectBlocks(), InstallSchema(), BasicUI::MakeProgress(), mProject, BasicUI::ProgressShowCancel, Query(), SetDBError(), BasicUI::Success, THROW_INCONSISTENCY_EXCEPTION, WriteDoc(), WriteXML(), WriteXMLHeader(), and XO().

Referenced by Compact(), SaveCopy(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

CurrConn()

Connection & ProjectFileIO::CurrConn ( )

private

Definition at line 1249 of file ProjectFileIO.cpp.

{
   auto &connectionPtr = ConnectionPtr::Get( mProject );
   return connectionPtr.mpConnection;
}

References ConnectionPtr::Get(), and mProject.

Referenced by CloseConnection(), CloseProject(), CopyTo(), GetBlockUsage(), GetConnection(), GetTotalUsage(), OpenConnection(), RestoreConnection(), SaveConnection(), SetBypass(), SetDBError(), SetError(), and UseConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

DB()

sqlite3 * ProjectFileIO::DB ( )

private

Definition at line 515 of file ProjectFileIO.cpp.

{
   return GetConnection().DB();
}

References DBConnection::DB(), and GetConnection().

Referenced by AutoSaveDelete(), CheckVersion(), CopyTo(), DeleteBlocks(), Exec(), LoadProject(), and WriteDoc().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteBlocks()

bool ProjectFileIO::DeleteBlocks	(	const BlockIDs &	blockids,
		bool	complement
	)

Definition at line 863 of file ProjectFileIO.cpp.

{
   auto db = DB();
   int rc;
 
   auto cleanup = finally([&]
   {
      // Remove our function, whether it was successfully defined or not.
      sqlite3_create_function(db, "inset", 1, SQLITE_UTF8 | SQLITE_DETERMINISTIC, nullptr, nullptr, nullptr, nullptr);
   });
 
   // Add the function used to verify each row's blockid against the set of active blockids
   const void *p = &blockids;
   rc = sqlite3_create_function(db, "inset", 1, SQLITE_UTF8 | SQLITE_DETERMINISTIC, const_cast<void*>(p), InSet, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::DeleteBlocks::create_function");
 
      /* i18n-hint: An error message.  Don't translate inset or blockids.*/
      SetDBError(XO("Unable to add 'inset' function (can't verify blockids)"));
      return false;
   }
 
   // Delete all rows in the set, or not in it
   // This is the first command that writes to the database, and so we
   // do more informative error reporting than usual, if it fails.
   auto sql = wxString::Format(
      "DELETE FROM sampleblocks WHERE %sinset(blockid);",
      complement ? "NOT " : "" );
   rc = sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.query", sql.ToStdString());
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::GetBlob");
 
      if( rc==SQLITE_READONLY)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Project is read only\n(Unable to work with the blockfiles)"));
      else if( rc==SQLITE_LOCKED)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Project is locked\n(Unable to work with the blockfiles)"));
      else if( rc==SQLITE_BUSY)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Project is busy\n(Unable to work with the blockfiles)"));
      else if( rc==SQLITE_CORRUPT)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Project is corrupt\n(Unable to work with the blockfiles)"));
      else if( rc==SQLITE_PERM)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Some permissions issue\n(Unable to work with the blockfiles)"));
      else if( rc==SQLITE_IOERR)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("A disk I/O error\n(Unable to work with the blockfiles)"));
      else if( rc==SQLITE_AUTH)
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Not authorized\n(Unable to work with the blockfiles)"));
      else
         /* i18n-hint: An error message.  Don't translate blockfiles.*/
         SetDBError(XO("Unable to work with the blockfiles"));
 
      return false;
   }
 
   // Mark the project recovered if we deleted any rows
   int changes = sqlite3_changes(db);
   if (changes > 0)
   {
      wxLogInfo(XO("Total orphan blocks deleted %d").Translation(), changes);
      mRecovered = true;
   }
 
   return true;
}

References ADD_EXCEPTION_CONTEXT, DB(), InSet(), mRecovered, SetDBError(), and XO().

Referenced by LoadProject(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

DiscardConnection()

void ProjectFileIO::DiscardConnection ( )

private

Definition at line 614 of file ProjectFileIO.cpp.

{
   if (mPrevConn)
   {
      if (!mPrevConn->Close())
      {
         // Store an error message
         SetDBError(
            XO("Failed to discard connection")
         );
      }
 
      // If this is a temporary project, we no longer want to keep the
      // project file.
      if (mPrevTemporary)
      {
         // This is just a safety check.
         wxFileName temp(TempDirectory::TempDir(), wxT(""));
         wxFileName file(mPrevFileName);
         file.SetFullName(wxT(""));
         if (file == temp)
         {
            if (!RemoveProject(mPrevFileName))
            {
               wxLogMessage("Failed to remove temporary project %s", mPrevFileName);
            }
         }
      }
      mPrevConn = nullptr;
      mPrevFileName.clear();
   }
}

References mPrevConn, mPrevFileName, mPrevTemporary, RemoveProject(), SetDBError(), TempDirectory::TempDir(), wxT(), and XO().

Referenced by LoadProject(), and SaveConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

Exec()

int ProjectFileIO::Exec ( const char *  query, const ExecCB &  callback, bool  silent = false  )

private

Definition at line 688 of file ProjectFileIO.cpp.

{
   char *errmsg = nullptr;
 
   const void *ptr = &callback;
   int rc = sqlite3_exec(DB(), query, ExecCallback,
                         const_cast<void*>(ptr), &errmsg);
 
   if (rc != SQLITE_ABORT && errmsg && !silent)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.query", query);
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
 
      SetDBError(
         XO("Failed to execute a project file command:\n\n%s").Format(query),
         Verbatim(errmsg),
         rc
      );
   }
   if (errmsg)
   {
      sqlite3_free(errmsg);
   }
 
   return rc;
}

References ADD_EXCEPTION_CONTEXT, DB(), ExecCallback(), SetDBError(), Verbatim(), and XO().

Referenced by Query().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateDoc()

wxString ProjectFileIO::GenerateDoc

(

)

Return a strings representation of the active project XML doc.

Definition at line 505 of file ProjectFileIO.cpp.

{
   auto &trackList = TrackList::Get( mProject );
 
   XMLStringWriter doc;
   WriteXMLHeader(doc);
   WriteXML(doc, false, trackList.empty() ? nullptr : &trackList);
   return doc;
}

References TrackList::Get(), mProject, WriteXML(), and WriteXMLHeader().

Here is the call graph for this function:

Get() [1/2]

ProjectFileIO & ProjectFileIO::Get ( AudacityProject &  project )

static

Definition at line 433 of file ProjectFileIO.cpp.

{
   auto &result = project.AttachedObjects::Get< ProjectFileIO >( sFileIOKey );
   return result;
}

References sFileIOKey.

Referenced by ProjectFileManager::AddImportedTracks(), OpenProjectCommand::Apply(), ProjectFileManager::CloseProject(), ProjectFileManager::Compact(), ProjectFileManager::CompactProjectOnClose(), DoImportMIDI(), ProjectFileManager::DoSave(), Get(), ProjectManager::GetEstimatedRecordingMinsLeftOnDisk(), ProjectFileManager::Import(), anonymous_namespace{ProjectFileManager.cpp}::ImportProject(), ProjectFileManager::IsAlreadyOpen(), ProjectAudioManager::OnAudioIONewBlocks(), ProjectAudioManager::OnAudioIOStopRecording(), TimerRecordDialog::OnAutoSavePathButton_Click(), ProjectManager::OnCloseWindow(), HistoryDialog::OnCompact(), ContrastDialog::OnExport(), ProjectWindow::OnProjectTitleChange(), ProjectManager::OnTimer(), anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord(), ProjectFileManager::OpenNewProject(), ProjectFileManager::OpenProject(), ProjectManager::OpenProject(), ProjectFileManager::OpenProjectFile(), AutoRecoveryDialog::PopulateList(), TimerRecordDialog::PopulateOrExchange(), ProjectAudioManager::ProjectAudioManager(), ProjectManager::ProjectManager(), ProjectWindow::ProjectWindow(), ProjectFileManager::ReadProjectFile(), RefreshAllTitles(), ProjectManager::ResetProjectToEmpty(), ProjectFileManager::Save(), ProjectFileManager::SaveAs(), ProjectFileManager::SaveCopy(), and ProjectFileManager::SaveFromTimerRecording().

Here is the caller graph for this function:

Get() [2/2]

const ProjectFileIO & ProjectFileIO::Get ( const AudacityProject &  project )

static

Definition at line 439 of file ProjectFileIO.cpp.

{
   return Get( const_cast< AudacityProject & >( project ) );
}

References Get().

Here is the call graph for this function:

get2()

static unsigned int ProjectFileIO::get2 ( const unsigned char *  ptr )

staticprivate

get4()

static unsigned int ProjectFileIO::get4 ( const unsigned char *  ptr )

staticprivate

get_varint()

static int ProjectFileIO::get_varint ( const unsigned char *  ptr, int64_t *  out  )

staticprivate

GetBlockUsage()

int64_t ProjectFileIO::GetBlockUsage

(

SampleBlockID

blockid

)

Definition at line 2533 of file ProjectFileIO.cpp.

{
   auto pConn = CurrConn().get();
   if (!pConn)
      return 0;
   return GetDiskUsage(*pConn, blockid);
}

References CurrConn(), and GetDiskUsage().

Here is the call graph for this function:

GetConnection()

DBConnection & ProjectFileIO::GetConnection

(

)

Return a reference to a connection, creating it as needed on demand; throw on failure.

Definition at line 485 of file ProjectFileIO.cpp.

{
   auto &curConn = CurrConn();
   if (!curConn)
   {
      if (!OpenConnection())
      {
         throw SimpleMessageBoxException
         {
            ExceptionType::Internal,
            XO("Failed to open the project's database"),
            XO("Warning"),
            "Error:_Disk_full_or_not_writable"
         };
      }
   }
 
   return *curConn;
}

References CurrConn(), Internal, OpenConnection(), and XO().

Referenced by DB().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCurrentUsage()

int64_t ProjectFileIO::GetCurrentUsage

(

const std::vector< const TrackList * > &

trackLists

)

const

Definition at line 2541 of file ProjectFileIO.cpp.

{
   unsigned long long current = 0;
   const auto fn = BlockSpaceUsageAccumulator(current);
 
   // Must pass address of this set, even if not otherwise used, to avoid
   // possible multiple count of shared blocks
   SampleBlockIDSet seen;
   for (auto pTracks: trackLists)
      if (pTracks)
         InspectBlocks(*pTracks, fn, &seen);
 
   return current;
}

References BlockSpaceUsageAccumulator(), fn, and InspectBlocks().

Here is the call graph for this function:

GetDiskUsage()

int64_t ProjectFileIO::GetDiskUsage ( DBConnection &  conn, SampleBlockID  blockid  )

static

Definition at line 2570 of file ProjectFileIO.cpp.

{
   sqlite3_stmt* stmt = nullptr;
 
   if (blockid == 0)
   {
      static const char* statement =
R"(SELECT 
   sum(length(blockid) + length(sampleformat) + 
   length(summin) + length(summax) + length(sumrms) + 
   length(summary256) + length(summary64k) +
   length(samples))
FROM sampleblocks;)";
 
      stmt = conn.Prepare(DBConnection::GetAllSampleBlocksSize, statement);
   }
   else
   {
      static const char* statement =
R"(SELECT 
   length(blockid) + length(sampleformat) + 
   length(summin) + length(summax) + length(sumrms) + 
   length(summary256) + length(summary64k) +
   length(samples)
FROM sampleblocks WHERE blockid = ?1;)";
 
      stmt = conn.Prepare(DBConnection::GetSampleBlockSize, statement);
   }
 
   auto cleanup = finally(
      [stmt]() {
         // Clear statement bindings and rewind statement
         if (stmt != nullptr)
         {
            sqlite3_clear_bindings(stmt);
            sqlite3_reset(stmt);
         }
      });
 
   if (blockid != 0)
   {
      int rc = sqlite3_bind_int64(stmt, 1, blockid);
 
      if (rc != SQLITE_OK)
      {
         ADD_EXCEPTION_CONTEXT(
            "sqlite3.rc", std::to_string(rc));
 
         ADD_EXCEPTION_CONTEXT(
            "sqlite3.context", "ProjectFileIO::GetDiskUsage::bind");
 
         conn.ThrowException(false);
      }
   }
 
   int rc = sqlite3_step(stmt);
 
   if (rc != SQLITE_ROW)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
 

References ADD_EXCEPTION_CONTEXT, DBConnection::GetAllSampleBlocksSize, DBConnection::GetSampleBlockSize, DBConnection::Prepare(), and DBConnection::ThrowException().

Referenced by GetBlockUsage(), SqliteSampleBlock::GetSpaceUsage(), and GetTotalUsage().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFileName()

const FilePath & ProjectFileIO::GetFileName

(

)

const

Definition at line 1618 of file ProjectFileIO.cpp.

{
   return mFileName;
}

References mFileName.

Referenced by ProjectFileManager::IsAlreadyOpen(), ContrastDialog::OnExport(), OpenConnection(), TimerRecordDialog::PopulateOrExchange(), and ProjectFileManager::SaveAs().

Here is the caller graph for this function:

GetFreeDiskSpace()

wxLongLong ProjectFileIO::GetFreeDiskSpace

(

)

const

Definition at line 2424 of file ProjectFileIO.cpp.

{
   wxLongLong freeSpace;
   if (wxGetDiskSpace(wxPathOnly(mFileName), NULL, &freeSpace))
   {
      if (FileNames::IsOnFATFileSystem(mFileName)) {
         // 4 GiB per-file maximum
         constexpr auto limit = 1ll << 32;
 
         // Opening a file only to find its length looks wasteful but
         // seems to be necessary at least on Windows with FAT filesystems.
         // I don't know if that is only a wxWidgets bug.
         auto length = wxFile{mFileName}.Length();
         // auto length = wxFileName::GetSize(mFileName);
 
         if (length == wxInvalidSize)
            length = 0;
         auto free = std::max<wxLongLong>(0, limit - length);
         freeSpace = std::min(freeSpace, free);
      }
      return freeSpace;
   }
 
   return -1;
}

References FileNames::IsOnFATFileSystem(), mFileName, and min().

Referenced by ProjectManager::GetEstimatedRecordingMinsLeftOnDisk(), and ProjectManager::OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLastError()

const TranslatableString & ProjectFileIO::GetLastError

(

)

const

Definition at line 2463 of file ProjectFileIO.cpp.

{
   return mpErrors->mLastError;
}

References mpErrors.

Referenced by SaveProject().

Here is the caller graph for this function:

GetLastErrorCode()

int ProjectFileIO::GetLastErrorCode

(

)

const

Definition at line 2473 of file ProjectFileIO.cpp.

{
    return mpErrors->mErrorCode;
}

References mpErrors.

Referenced by CheckVersion().

Here is the caller graph for this function:

GetLastLog()

const wxString & ProjectFileIO::GetLastLog

(

)

const

Definition at line 2478 of file ProjectFileIO.cpp.

{
    return mpErrors->mLog;
}

References mpErrors.

Referenced by ShowError().

Here is the caller graph for this function:

GetLibraryError()

const TranslatableString & ProjectFileIO::GetLibraryError

(

)

const

Definition at line 2468 of file ProjectFileIO.cpp.

{
   return mpErrors->mLibraryError;
}

References mpErrors.

Referenced by CheckVersion().

Here is the caller graph for this function:

GetProjectTitle()

const wxString & ProjectFileIO::GetProjectTitle ( ) const

inline

Definition at line 79 of file ProjectFileIO.h.

{ return mTitle; }

Referenced by ProjectWindow::OnProjectTitleChange().

Here is the caller graph for this function:

GetTotalUsage()

int64_t ProjectFileIO::GetTotalUsage

(

)

Definition at line 2557 of file ProjectFileIO.cpp.

{
   auto pConn = CurrConn().get();
   if (!pConn)
      return 0;
   return GetDiskUsage(*pConn, 0);
}

References CurrConn(), and GetDiskUsage().

Referenced by ShouldCompact().

Here is the call graph for this function:

Here is the caller graph for this function:

GetValue() [1/2]

bool ProjectFileIO::GetValue ( const char *  sql, int64_t &  value, bool  silent = false  )

private

Definition at line 742 of file ProjectFileIO.cpp.

{
   bool success = false;
   auto cb = [&value, &success](int cols, char** vals, char**)
   {
      if (cols > 0)
      {
         const std::string_view valueString = vals[0];
 
         success = std::errc() ==
            FromChars(
               valueString.data(), valueString.data() + valueString.length(),
               value)
               .ec;
      }
      // Stop after one row
      return 1;
   };
 
   return Query(sql, cb, silent) && success;
}

References FromCharsResult::ec, FromChars(), and Query().

Here is the call graph for this function:

GetValue() [2/2]

bool ProjectFileIO::GetValue ( const char *  sql, wxString &  value, bool  silent = false  )

private

Definition at line 728 of file ProjectFileIO.cpp.

{
   // Retrieve the first column in the first row, if any
   result.clear();
   auto cb = [&result](int cols, char **vals, char **){
      if (cols > 0)
         result = vals[0];
      // Stop after one row
      return 1;
   };
 
   return Query(sql, cb, silent);
}

References Query().

Referenced by CheckVersion(), LoadProject(), and WriteDoc().

Here is the call graph for this function:

Here is the caller graph for this function:

HadUnused()

bool ProjectFileIO::HadUnused

(

)

Definition at line 1569 of file ProjectFileIO.cpp.

{
   return mHadUnused;
}

References mHadUnused.

Referenced by SetBypass().

Here is the caller graph for this function:

HandleXMLChild()

XMLTagHandler * ProjectFileIO::HandleXMLChild ( const std::string_view &  tag )

overrideprivatevirtual

Implements XMLTagHandler.

Definition at line 1730 of file ProjectFileIO.cpp.

{
   auto &project = mProject;
   return ProjectFileIORegistry::Get().CallObjectAccessor(tag, project);
}

References XMLMethodRegistry< Host >::CallObjectAccessor(), XMLMethodRegistry< Host >::Get(), and mProject.

Here is the call graph for this function:

HandleXMLTag()

bool ProjectFileIO::HandleXMLTag ( const std::string_view &  tag, const AttributesList &  attrs  )

overrideprivatevirtual

Implements XMLTagHandler.

Definition at line 1651 of file ProjectFileIO.cpp.

{
   auto &project = mProject;
 
   wxString fileVersion;
   wxString audacityVersion;
   int requiredTags = 0;
 
   // loop through attrs, which is a null-terminated list of
   // attribute-value pairs
   for (auto pair : attrs)
   {
      auto attr = pair.first;
      auto value = pair.second;
 
      if ( ProjectFileIORegistry::Get()
          .CallAttributeHandler( attr, project, value ) )
         continue;
 
      else if (attr == "version")
      {
         fileVersion = value.ToWString();
         requiredTags++;
      }
 
      else if (attr == "audacityversion")
      {
         audacityVersion = value.ToWString();
         requiredTags++;
      }
   } // while
 
   if (requiredTags < 2)
   {
      return false;
   }
 
   // Parse the file version from the project
   int fver;
   int frel;
   int frev;
   if (!wxSscanf(fileVersion, wxT("%i.%i.%i"), &fver, &frel, &frev))
   {
      return false;
   }
 
   // Parse the file version Audacity was build with
   int cver;
   int crel;
   int crev;
   wxSscanf(wxT(AUDACITY_FILE_FORMAT_VERSION), wxT("%i.%i.%i"), &cver, &crel, &crev);
 
   int fileVer = ((fver *100)+frel)*100+frev;
   int codeVer = ((cver *100)+crel)*100+crev;
 
   if (codeVer<fileVer)
   {
      /* i18n-hint: %s will be replaced by the version number.*/
      auto msg = XO("This file was saved using Audacity %s.\nYou are using Audacity %s. You may need to upgrade to a newer version to open this file.")
         .Format(audacityVersion, AUDACITY_VERSION_STRING);
 
      ShowError( *ProjectFramePlacement(&project),
         XO("Can't open project file"),
         msg, 
         "FAQ:Errors_opening_an_Audacity_project"
         );
 
      return false;
   }
 
   if (tag != "project")
   {
      return false;
   }
 
   // All other tests passed, so we succeed
   return true;
}

References AUDACITY_FILE_FORMAT_VERSION, XMLMethodRegistry< Host >::Get(), mProject, ProjectFramePlacement(), ShowError(), wxT(), and XO().

Here is the call graph for this function:

HasConnection()

bool ProjectFileIO::HasConnection

(

)

const

Return true if a connection is now open.

Definition at line 479 of file ProjectFileIO.cpp.

{
   auto &connectionPtr = ConnectionPtr::Get( mProject );
   return connectionPtr.mpConnection != nullptr;
}

References ConnectionPtr::Get(), and mProject.

Here is the call graph for this function:

InitializeSQL()

bool ProjectFileIO::InitializeSQL ( )

static

Definition at line 420 of file ProjectFileIO.cpp.

{
   static SQLiteIniter sqliteIniter;
   return sqliteIniter.mRc == SQLITE_OK;
}

References SQLiteIniter::mRc.

Referenced by AudacityApp::OnInit0().

Here is the caller graph for this function:

InSet()

void ProjectFileIO::InSet ( sqlite3_context *  context, int  argc, sqlite3_value **  argv  )

staticprivate

Definition at line 855 of file ProjectFileIO.cpp.

{
   BlockIDs *blockids = (BlockIDs *) sqlite3_user_data(context);
   SampleBlockID blockid = sqlite3_value_int64(argv[0]);
 
   sqlite3_result_int(context, blockids->find(blockid) != blockids->end());
}

References CommandLineArgs::argv.

Referenced by DeleteBlocks().

Here is the caller graph for this function:

InstallSchema()

bool ProjectFileIO::InstallSchema ( sqlite3 *  db, const char *  schema = "main"  )

private

Definition at line 829 of file ProjectFileIO.cpp.

{
   int rc;
 
   wxString sql;
   sql.Printf(ProjectFileSchema, ProjectFileID, BaseProjectFormatVersion.GetPacked());
   sql.Replace("<schema>", schema);
 
   rc = sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
   if (rc != SQLITE_OK)
   {
      SetDBError(
         XO("Unable to initialize the project file")
      );
      return false;
   }
 
   return true;
}

References BaseProjectFormatVersion, ProjectFormatVersion::GetPacked(), ProjectFileID, ProjectFileSchema, SetDBError(), and XO().

Referenced by CheckVersion(), and CopyTo().

Here is the call graph for this function:

Here is the caller graph for this function:

IsModified()

bool ProjectFileIO::IsModified

(

)

const

Definition at line 2409 of file ProjectFileIO.cpp.

{
   return mModified;
}

References mModified.

Referenced by Compact(), and anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord().

Here is the caller graph for this function:

IsRecovered()

bool ProjectFileIO::IsRecovered

(

)

const

Definition at line 2419 of file ProjectFileIO.cpp.

{
   return mRecovered;
}

References mRecovered.

IsTemporary()

bool ProjectFileIO::IsTemporary

(

)

const

Definition at line 2414 of file ProjectFileIO.cpp.

{
   return mTemporary;
}

References mTemporary.

Referenced by CloseProject(), Compact(), SaveProject(), SetBypass(), and SetFileName().

Here is the caller graph for this function:

LoadProject()

bool ProjectFileIO::LoadProject	(	const FilePath &	fileName,
		bool	ignoreAutosave
	)

Definition at line 2007 of file ProjectFileIO.cpp.

{
   auto now = std::chrono::high_resolution_clock::now();
 
   bool success = false;
 
   auto cleanup = finally([&]
   {
      if (!success)
      {
         RestoreConnection();
      }
   });
 
   SaveConnection();
 
   // Open the project file
   if (!OpenConnection(fileName))
   {
      return false;
   }
 
   int64_t rowId = -1;
 
   bool useAutosave =
      !ignoreAutosave &&
      GetValue("SELECT ROWID FROM main.autosave WHERE id = 1;", rowId, true);
 
   int64_t rowsCount = 0;
   // If we didn't have an autosave doc, load the project doc instead
   if (
      !useAutosave &&
      (!GetValue("SELECT COUNT(1) FROM main.project;", rowsCount, true) || rowsCount == 0))
   {
      // Missing both the autosave and project docs. This can happen if the
      // system were to crash before the first autosave into a temporary file.
      // This should be a recoverable scenario.
      mRecovered = true;
      mModified = true;
 
      return true;
   }
 
   if (!useAutosave && !GetValue("SELECT ROWID FROM main.project WHERE id = 1;", rowId, false))
   {
      return false;
   }
   else
   {
      // Load 'er up
      BufferedProjectBlobStream stream(
         DB(), "main", useAutosave ? "autosave" : "project", rowId);
 
      success = ProjectSerializer::Decode(stream, this);
 
      if (!success)
      {
         SetError(
            XO("Unable to parse project information.")
         );
         return false;
      }
 
      // Check for orphans blocks...sets mRecovered if any were deleted
      
      auto blockids = WaveTrackFactory::Get( mProject )
         .GetSampleBlockFactory()
            ->GetActiveBlockIDs();
      if (blockids.size() > 0)
      {
         success = DeleteBlocks(blockids, true);
         if (!success)
         {
            return false;
         }
      }
   
      // Remember if we used autosave or not
      if (useAutosave)
      {
         mRecovered = true;
      }
   }
 
   // Mark the project modified if we recovered it
   if (mRecovered)
   {
      mModified = true;
   }
 
   // A previously saved project will have a document in the project table, so
   // we use that knowledge to determine if this file is an unsaved/temporary
   // file or a permanent project file
   wxString result;
   success = GetValue("SELECT Count(*) FROM project;", result);
   if (!success)
   {
      return false;
   }
 
   mTemporary = !result.IsSameAs(wxT("1"));
 
   SetFileName(fileName);
 
   DiscardConnection();
 
   success = true;
 
   auto duration = std::chrono::high_resolution_clock::now() - now;
 
   wxLogInfo(
      "Project loaded in %lld ms",
      std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
 
   return true;
}

References DB(), ProjectSerializer::Decode(), DeleteBlocks(), DiscardConnection(), WaveTrackFactory::Get(), WaveTrackFactory::GetSampleBlockFactory(), GetValue(), mModified, mProject, mRecovered, mTemporary, OpenConnection(), RestoreConnection(), SaveConnection(), SetError(), SetFileName(), wxT(), and XO().

Here is the call graph for this function:

MoveProject()

bool ProjectFileIO::MoveProject ( const FilePath &  src, const FilePath &  dst  )

private

Definition at line 1342 of file ProjectFileIO.cpp.

{
   // Assume the src database file is not busy.
   if (!RenameOrWarn(src, dst))
      return false;
 
   // So far so good, but the separate -wal and -shm files might yet exist,
   // as when checkpointing failed for limited space on the drive.
   // If so move them too or else lose data.
 
   std::vector< std::pair<FilePath, FilePath> > pairs{ { src, dst } };
   bool success = false;
   auto cleanup = finally([&]{
      if (!success) {
         // If any one of the renames failed, back out the previous ones.
         // This should be a no-fail recovery!  Not clear what to do if any
         // of these renames fails.
         for (auto &pair : pairs) {
            if (!(pair.first.empty() && pair.second.empty()))
               wxRenameFile(pair.second, pair.first);
         }
      }
   });
 
   for (const auto &suffix : AuxiliaryFileSuffixes()) {
      auto srcName = src + suffix;
      if (wxFileExists(srcName)) {
         auto dstName = dst + suffix;
         if (!RenameOrWarn(srcName, dstName))
            return false;
         pairs.push_back({ srcName, dstName });
      }
   }
 
   return (success = true);
}

References AuxiliaryFileSuffixes(), and RenameOrWarn().

Referenced by ProjectFileIO::BackupProject::BackupProject(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCheckpointFailure()

void ProjectFileIO::OnCheckpointFailure ( )

private

Definition at line 1736 of file ProjectFileIO.cpp.

{
   // DBConnection promises to invoke this in main thread idle time
   // So we don't need a redundant CallAfter to satisfy our own promise
   Publish(ProjectFileIOMessage::CheckpointFailure);
}

References CheckpointFailure, and Observer::Publisher< ProjectFileIOMessage >::Publish().

Here is the call graph for this function:

OpenConnection()

bool ProjectFileIO::OpenConnection ( FilePath  fileName = {} )

private

Precondition

*CurConn() does not exist

Postcondition

*CurConn() exists or return value is false

Definition at line 524 of file ProjectFileIO.cpp.

{
   auto &curConn = CurrConn();
   wxASSERT(!curConn);
   bool isTemp = false;
 
   if (fileName.empty())
   {
      fileName = GetFileName();
      if (fileName.empty())
      {
         fileName = TempDirectory::UnsavedProjectFileName();
         isTemp = true;
      }
   }
   else
   {
      // If this project resides in the temporary directory, then we'll mark it
      // as temporary.
      wxFileName temp(TempDirectory::TempDir(), wxT(""));
      wxFileName file(fileName);
      file.SetFullName(wxT(""));
      if (file == temp)
      {
         isTemp = true;
      }
   }
 
   // Pass weak_ptr to project into DBConnection constructor
   curConn = std::make_unique<DBConnection>(
      mProject.shared_from_this(), mpErrors, [this]{ OnCheckpointFailure(); } );
   auto rc = curConn->Open(fileName);
   if (rc != SQLITE_OK)
   {
      // Must use SetError() here since we do not have an active DB
      SetError(
         XO("Failed to open database file:\n\n%s").Format(fileName),
         {},
         rc
      );
      curConn.reset();
      return false;
   }
 
   if (!CheckVersion())
   {
      CloseConnection();
      curConn.reset();
      return false;
   }
 
   mTemporary = isTemp;
 
   SetFileName(fileName);
 
   return true;
}

References CheckVersion(), CloseConnection(), CurrConn(), GetFileName(), mpErrors, mProject, mTemporary, SetError(), SetFileName(), TempDirectory::TempDir(), TempDirectory::UnsavedProjectFileName(), wxT(), and XO().

Referenced by Compact(), GetConnection(), LoadProject(), OpenProject(), ReopenProject(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenProject()

bool ProjectFileIO::OpenProject

(

)

Definition at line 2361 of file ProjectFileIO.cpp.

{
   return OpenConnection();
}

References OpenConnection().

Here is the call graph for this function:

operator=()

ProjectFileIO & ProjectFileIO::operator= ( const ProjectFileIO &  )

delete

Query()

bool ProjectFileIO::Query ( const char *  sql, const ExecCB &  callback, bool  silent = false  )

private

Definition at line 715 of file ProjectFileIO.cpp.

{
   int rc = Exec(sql, callback, silent);
   // SQLITE_ABORT is a non-error return only meaning the callback
   // stopped the iteration of rows early
   if ( !(rc == SQLITE_OK || rc == SQLITE_ABORT) )
   {
      return false;
   }
 
   return true;
}

References Exec().

Referenced by CopyTo(), GetValue(), ShouldCompact(), and WriteDoc().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveProject()

bool ProjectFileIO::RemoveProject ( const FilePath &  filename )

static

Remove any files associated with a project at given path; return true if successful.

Definition at line 1379 of file ProjectFileIO.cpp.

{
   if (!wxFileExists(filename))
      return false;
 
   bool success = wxRemoveFile(filename);
   auto &suffixes = AuxiliaryFileSuffixes();
   for (const auto &suffix : suffixes) {
      auto file = filename + suffix;
      if (wxFileExists(file))
         success = wxRemoveFile(file) && success;
   }
   return success;
}

References AuxiliaryFileSuffixes().

Referenced by CloseProject(), ProjectFileIO::BackupProject::Discard(), DiscardConnection(), and AutoRecoveryDialog::OnDiscardSelected().

Here is the call graph for this function:

Here is the caller graph for this function:

RenameOrWarn()

bool ProjectFileIO::RenameOrWarn ( const FilePath &  src, const FilePath &  dst  )

private

Rename a file or put up appropriate warning message.

Failure might happen when renaming onto another device, doing copy of contents

Definition at line 1301 of file ProjectFileIO.cpp.

{
   std::atomic_bool done = {false};
   bool success = false;
   auto thread = std::thread([&]
   {
      success = wxRenameFile(src, dst);
      done = true;
   });
 
   // Provides a progress dialog with indeterminate mode
   using namespace BasicUI;
   auto pd = MakeGenericProgress(*ProjectFramePlacement(&mProject),
      XO("Copying Project"), XO("This may take several seconds"));
   wxASSERT(pd);
 
   // Wait for the checkpoints to end
   while (!done)
   {
      using namespace std::chrono;
      std::this_thread::sleep_for(50ms);
      pd->Pulse();
   }
   thread.join();
 
   if (!success)
   {
      ShowError( *ProjectFramePlacement(&mProject),
         XO("Error Writing to File"),
         XO("Audacity failed to write file %s.\n"
            "Perhaps disk is full or not writable.\n"
            "For tips on freeing up space, click the help button.")
            .Format(dst),
         "Error:_Disk_full_or_not_writable"
         );
      return false;
   }
 
   return true;
}

References BasicUI::MakeGenericProgress(), mProject, ProjectFramePlacement(), ShowError(), and XO().

Referenced by MoveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

ReopenProject()

bool ProjectFileIO::ReopenProject

(

)

Definition at line 2398 of file ProjectFileIO.cpp.

{
   FilePath fileName = mFileName;
   if (!CloseConnection())
   {
      return false;
   }
 
   return OpenConnection(fileName);
}

References CloseConnection(), mFileName, and OpenConnection().

Here is the call graph for this function:

RestoreConnection()

void ProjectFileIO::RestoreConnection ( )

private

Definition at line 648 of file ProjectFileIO.cpp.

{
   auto &curConn = CurrConn();
   if (curConn)
   {
      if (!curConn->Close())
      {
         // Store an error message
         SetDBError(
            XO("Failed to restore connection")
         );
      }
   }
 
   curConn = std::move(mPrevConn);
   SetFileName(mPrevFileName);
   mTemporary = mPrevTemporary;
 
   mPrevFileName.clear();
}

References CurrConn(), mPrevConn, mPrevFileName, mPrevTemporary, mTemporary, SetDBError(), SetFileName(), and XO().

Referenced by LoadProject().

Here is the call graph for this function:

Here is the caller graph for this function:

SafetyFileName()

FilePath ProjectFileIO::SafetyFileName ( const FilePath &  src )

staticprivate

Generate a name for short-lived backup project files from an existing project.

Definition at line 1266 of file ProjectFileIO.cpp.

{
   wxFileNameWrapper fn{ src };
 
   // Extra characters inserted into filename before extension
   wxString extra =
#ifdef __WXGTK__
      wxT("~")
#else
      wxT(".bak")
#endif
   ;
 
   int nn = 1;
   auto numberString = [](int num) -> wxString {
      return num == 1 ? wxString{} : wxString::Format(".%d", num);
   };
 
   auto suffixes = AuxiliaryFileSuffixes();
   suffixes.push_back({});
 
   // Find backup paths not already occupied; check all auxiliary suffixes
   const auto name = fn.GetName();
   FilePath result;
   do {
      fn.SetName( name + numberString(nn++) + extra );
      result = fn.GetFullPath();
   }
   while( std::any_of(suffixes.begin(), suffixes.end(), [&](auto &suffix){
      return wxFileExists(result + suffix);
   }) );
 
   return result;
}

References AuxiliaryFileSuffixes(), fn, name, and wxT().

Referenced by ProjectFileIO::BackupProject::BackupProject().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveConnection()

void ProjectFileIO::SaveConnection ( )

private

Definition at line 601 of file ProjectFileIO.cpp.

{
   // Should do nothing in proper usage, but be sure not to leak a connection:
   DiscardConnection();
 
   mPrevConn = std::move(CurrConn());
   mPrevFileName = mFileName;
   mPrevTemporary = mTemporary;
 
   SetFileName({});
}

References CurrConn(), DiscardConnection(), mFileName, mPrevConn, mPrevFileName, mPrevTemporary, mTemporary, and SetFileName().

Referenced by LoadProject().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveCopy()

bool ProjectFileIO::SaveCopy

(

const FilePath &

fileName

)

Definition at line 2355 of file ProjectFileIO.cpp.

{
   return CopyTo(fileName, XO("Backing up project"), false, true,
      {&TrackList::Get(mProject)});
}

References CopyTo(), TrackList::Get(), mProject, and XO().

Here is the call graph for this function:

SaveProject()

bool ProjectFileIO::SaveProject	(	const FilePath &	fileName,
		const TrackList *	lastSaved
	)

Definition at line 2147 of file ProjectFileIO.cpp.

{
   // In the case where we're saving a temporary project to a permanent project,
   // we'll try to simply rename the project to save a bit of time. We then fall
   // through to the normal Save (not SaveAs) processing.
   if (IsTemporary() && mFileName != fileName)
   {
      FilePath savedName = mFileName;
      if (CloseConnection())
      {
         bool reopened = false;
         bool moved = false;
         if (true == (moved = MoveProject(savedName, fileName)))
         {
            if (OpenConnection(fileName))
               reopened = true;
            else {
               MoveProject(fileName, savedName);
               moved = false; // No longer moved
 
               reopened = OpenConnection(savedName);
            }
         }
         else {
            // Rename can fail -- if it's to a different device, requiring
            // real copy of contents, which might exhaust space
            reopened = OpenConnection(savedName);
         }
 
         // Warning issued in MoveProject()
         if (reopened && !moved) {
            return false;
         }
 
         if (!reopened) {
            BasicUI::CallAfter([this]{
               ShowError( {},
                  XO("Warning"),
                  XO(
"The project's database failed to reopen, "
"possibly because of limited space on the storage device."),
                  "Error:_Disk_full_or_not_writable"
               );
               Publish(ProjectFileIOMessage::ReconnectionFailure);
            });
 
            return false;
         }
      }
   }
 
   // If we're saving to a different file than the current one, then copy the
   // current to the new file and make it the active file.
   if (mFileName != fileName)
   {
      // Do NOT prune here since we need to retain the Undo history
      // after we switch to the new file.
      if (!CopyTo(fileName, XO("Saving project"), false))
      {
         ShowError( {},
            XO("Error Saving Project"),
            FileException::WriteFailureMessage(fileName),
            "Error:_Disk_full_or_not_writable"
            );
         return false;
      }
 
      // Open the newly created database
      Connection newConn = std::make_unique<DBConnection>(
         mProject.shared_from_this(), mpErrors,
         [this]{ OnCheckpointFailure(); });
 
      // NOTE: There is a noticeable delay here when dealing with large multi-hour
      //       projects that we just created. The delay occurs in Open() when it
      //       calls SafeMode() and is due to the switch from the NONE journal mode
      //       to the WAL journal mode.
      //
      //       So, we do the Open() in a thread and display a progress dialog. Since
      //       this is currently the only known instance where this occurs, we do the
      //       threading here. If more instances are identified, then the threading
      //       should be moved to DBConnection::Open(), wrapping the SafeMode() call
      //       there.
      {
         std::atomic_bool done = {false};
         bool success = true;
         auto thread = std::thread([&]
         {
            auto rc =  newConn->Open(fileName);
            if (rc != SQLITE_OK)
            {
               // Capture the error string
               SetError(Verbatim(sqlite3_errstr(rc)));
               success = false;
            }
            done = true;
         });
 
         // Provides a progress dialog with indeterminate mode
         using namespace BasicUI;
         auto pd = MakeGenericProgress({},
            XO("Syncing"), XO("This may take several seconds"));
         wxASSERT(pd);
 
         // Wait for the checkpoints to end
         while (!done)
         {
            using namespace std::chrono;
            std::this_thread::sleep_for(50ms);
            pd->Pulse();
         }
         thread.join();
 
         if (!success)
         {
            // Additional help via a Help button links to the manual.
            ShowError( {},
                      XO("Error Saving Project"),
                      XO("The project failed to open, possibly due to limited space\n"
                         "on the storage device.\n\n%s").Format(GetLastError()),
                      "Error:_Disk_full_or_not_writable");
 
            newConn = nullptr;
 
            // Clean up the destination project
            if (!wxRemoveFile(fileName))
            {
               wxLogMessage("Failed to remove destination project after open failure: %s", fileName);
            }
 
            return false;
         }
      }
 
      // Autosave no longer needed in original project file.
      if (!AutoSaveDelete())
      {
         // Additional help via a Help button links to the manual.
         ShowError( {},
                   XO("Error Saving Project"),
                   XO("Unable to remove autosave information, possibly due to limited space\n"
                      "on the storage device.\n\n%s").Format(GetLastError()),
                  "Error:_Disk_full_or_not_writable");
 
         newConn = nullptr;
 
         // Clean up the destination project
         if (!wxRemoveFile(fileName))
         {
            wxLogMessage("Failed to remove destination project after AutoSaveDelete failure: %s", fileName);
         }
 
         return false;
      }
 
      if (lastSaved) {
         // Bug2605: Be sure not to save orphan blocks
         bool recovered = mRecovered;
         SampleBlockIDSet blockids;
         InspectBlocks( *lastSaved, {}, &blockids );
         // TODO: Not sure what to do if the deletion fails
         DeleteBlocks(blockids, true);
         // Don't set mRecovered if any were deleted
         mRecovered = recovered;
      }
 
      // Try to compact the original project file.
      auto empty = TrackList::Create(&mProject);
      Compact( { lastSaved ? lastSaved : empty.get() }, true );
 
      // Safe to close the original project file now. Not much we can do if this fails,
      // but we should still be in good shape since we'll be switching to the newly
      // saved database below.
      CloseProject();
 
      // And make it the active project file 
      UseConnection(std::move(newConn), fileName);
   }
   else
   {
      if ( !UpdateSaved( nullptr ) ) {
         ShowError( {},
            XO("Error Saving Project"),
            FileException::WriteFailureMessage(fileName),
            "Error:_Disk_full_or_not_writable"
            );
         return false;
      }
   }
 
   // Reaching this point defines success and all the rest are no-fail
   // operations:
 
   // No longer modified
   mModified = false;
 
   // No longer recovered
   mRecovered = false;
 
   // No longer a temporary project
   mTemporary = false;
 
   // Adjust the title
   SetProjectTitle();
 
   return true;
}

References AutoSaveDelete(), BasicUI::CallAfter(), CloseConnection(), CloseProject(), Compact(), CopyTo(), TrackList::Create(), DeleteBlocks(), GetLastError(), InspectBlocks(), IsTemporary(), BasicUI::MakeGenericProgress(), mFileName, mModified, MoveProject(), mpErrors, mProject, mRecovered, mTemporary, OpenConnection(), Observer::Publisher< ProjectFileIOMessage >::Publish(), ReconnectionFailure, SetError(), SetProjectTitle(), ShowError(), UpdateSaved(), UseConnection(), Verbatim(), FileException::WriteFailureMessage(), and XO().

Here is the call graph for this function:

SetBypass()

void ProjectFileIO::SetBypass

(

)

Definition at line 2499 of file ProjectFileIO.cpp.

{
   auto &currConn = CurrConn();
   if (!currConn)
      return;
 
   // Determine if we can bypass sample block deletes during shutdown.
   //
   // IMPORTANT:
   // If the project was compacted, then we MUST bypass further
   // deletions since the new file doesn't have the blocks that the
   // Sequences expect to be there.
 
   currConn->SetBypass( true );
 
   // Only permanent project files need cleaning at shutdown
   if (!IsTemporary() && !WasCompacted())
   {
      // If we still have unused blocks, then we must not bypass deletions
      // during shutdown.  Otherwise, we would have orphaned blocks the next time
      // the project is opened.
      //
      // An example of when dead blocks will exist is when a user opens a permanent
      // project, adds a track (with samples) to it, and chooses not to save the
      // changes.
      if (HadUnused())
      {
         currConn->SetBypass( false );
      }
   }
 
   return;
}

References CurrConn(), HadUnused(), IsTemporary(), and WasCompacted().

Here is the call graph for this function:

SetDBError()

void ProjectFileIO::SetDBError ( const TranslatableString &  msg, const TranslatableString &  libraryError = {}, int  errorCode = -1  )

private

Set stored errors and write to log; and default libraryError to what database library reports.

Definition at line 2491 of file ProjectFileIO.cpp.

{
   auto &currConn = CurrConn();
   if (currConn)
      currConn->SetDBError(msg, libraryError, errorCode);
}

References CurrConn().

Referenced by AutoSaveDelete(), CopyTo(), DeleteBlocks(), DiscardConnection(), Exec(), InstallSchema(), RestoreConnection(), and WriteDoc().

Here is the call graph for this function:

Here is the caller graph for this function:

SetError()

void ProjectFileIO::SetError ( const TranslatableString &  msg, const TranslatableString &  libraryError = {}, int  errorCode = {}  )

private

Just set stored errors.

Definition at line 2483 of file ProjectFileIO.cpp.

{
   auto &currConn = CurrConn();
   if (currConn)
      currConn->SetError(msg, libraryError, errorCode);
}

References CurrConn().

Referenced by CheckVersion(), LoadProject(), OpenConnection(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFileName()

void ProjectFileIO::SetFileName

(

const FilePath &

fileName

)

Definition at line 1623 of file ProjectFileIO.cpp.

{
   auto &project = mProject;
 
   if (!mFileName.empty())
   {
      ActiveProjects::Remove(mFileName);
   }
 
   mFileName = fileName;
 
   if (!mFileName.empty())
   {
      ActiveProjects::Add(mFileName);
   }
 
   if (IsTemporary())
   {
      project.SetProjectName({});
   }
   else
   {
      project.SetProjectName(wxFileName(mFileName).GetName());
   }
 
   SetProjectTitle();
}

References ActiveProjects::Add(), IsTemporary(), mFileName, mProject, ActiveProjects::Remove(), and SetProjectTitle().

Referenced by CloseConnection(), LoadProject(), OpenConnection(), RestoreConnection(), SaveConnection(), and UseConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

SetProjectTitle()

void ProjectFileIO::SetProjectTitle

(

int

number = -1

)

Definition at line 1580 of file ProjectFileIO.cpp.

{
   auto &project = mProject;
   wxString name = project.GetProjectName();
 
   // If we are showing project numbers, then we also explicitly show "<untitled>" if there
   // is none.
   if (number >= 0)
   {
      name =
      /* i18n-hint: The %02i is the project number, the %s is the project name.*/
      XO("[Project %02i] Audacity \"%s\"")
         .Format( number + 1,
                 name.empty() ? XO("<untitled>") : Verbatim((const char *)name))
         .Translation();
   }
   // If we are not showing numbers, then <untitled> shows as 'Audacity'.
   else if (name.empty())
   {
      name = _TS("Audacity");
   }
 
   if (mRecovered)
   {
      name += wxT(" ");
      /* i18n-hint: E.g this is recovered audio that had been lost.*/
      name += _("(Recovered)");
   }
 
   if (name != mTitle) {
      mTitle = name;
      BasicUI::CallAfter( [wThis = weak_from_this()]{
         if (auto pThis = wThis.lock())
            pThis->Publish(ProjectFileIOMessage::ProjectTitleChange);
      } );
   }
}

References _, _TS, BasicUI::CallAfter(), TranslatableString::empty(), mProject, mRecovered, mTitle, name, ProjectTitleChange, Verbatim(), wxT(), and XO().

Referenced by ProjectFileIO(), RefreshAllTitles(), SaveProject(), SetFileName(), and UpdatePrefs().

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldCompact()

bool ProjectFileIO::ShouldCompact ( const std::vector< const TrackList * > &  tracks )

private

Definition at line 1201 of file ProjectFileIO.cpp.

{
   SampleBlockIDSet active;
   unsigned long long current = 0;
 
   {
      auto fn = BlockSpaceUsageAccumulator( current );
      for (auto pTracks : tracks)
         if (pTracks)
            InspectBlocks( *pTracks, fn,
               &active // Visit unique blocks only
            );
   }
 
   // Get the number of blocks and total length from the project file.
   unsigned long long total = GetTotalUsage();
   unsigned long long blockcount = 0;
   
   auto cb = [&blockcount](int cols, char **vals, char **)
   {
      // Convert
      wxString(vals[0]).ToULongLong(&blockcount);
      return 0;
   };
 
   if (!Query("SELECT Count(*) FROM sampleblocks;", cb) || blockcount == 0)
   {
      // Shouldn't compact since we don't have the full picture
      return false;
   }
 
   // Remember if we had unused blocks in the project file
   mHadUnused = (blockcount > active.size());
 
   // Let's make a percentage...should be plenty of head room
   current *= 100;
 
   wxLogDebug(wxT("used = %lld total = %lld %lld"), current, total, total ? current / total : 0);
   if (!total || current / total > 80)
   {
      wxLogDebug(wxT("not compacting"));
      return false;
   }
   wxLogDebug(wxT("compacting"));
 
   return true;
}

References BlockSpaceUsageAccumulator(), fn, GetTotalUsage(), InspectBlocks(), mHadUnused, Query(), and wxT().

Referenced by Compact().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowError()

void ProjectFileIO::ShowError	(	const BasicUI::WindowPlacement &	placement,
		const TranslatableString &	dlogTitle,
		const TranslatableString &	message,
		const wxString &	helpPage
	)

Displays an error dialog with a button that offers help.

Definition at line 2451 of file ProjectFileIO.cpp.

{
   using namespace audacity;
   using namespace BasicUI;
   ShowErrorDialog( placement, dlogTitle, message, helpPage,
      ErrorDialogOptions{ ErrorDialogType::ModalErrorReport }
         .Log(ToWString(GetLastLog())));
}

References GetLastLog(), BasicUI::ErrorDialogOptions::Log(), BasicUI::ShowErrorDialog(), and audacity::ToWString().

Referenced by HandleXMLTag(), RenameOrWarn(), and SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdatePrefs()

void ProjectFileIO::UpdatePrefs ( )

overrideprivatevirtual

Implements PrefsListener.

Definition at line 1574 of file ProjectFileIO.cpp.

{
   SetProjectTitle();
}

References SetProjectTitle().

Here is the call graph for this function:

UpdateSaved()

bool ProjectFileIO::UpdateSaved

(

const TrackList *

tracks = nullptr

)

Definition at line 2124 of file ProjectFileIO.cpp.

{
   ProjectSerializer doc;
   WriteXMLHeader(doc);
   WriteXML(doc, false, tracks);
 
   if (!WriteDoc("project", doc))
   {
      return false;
   }
 
   // Autosave no longer needed
   if (!AutoSaveDelete())
   {
      return false;
   }
 
   return true;
}

References AutoSaveDelete(), WriteDoc(), WriteXML(), and WriteXMLHeader().

Referenced by SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

UseConnection()

void ProjectFileIO::UseConnection ( Connection &&  conn, const FilePath &  filePath  )

private

Definition at line 669 of file ProjectFileIO.cpp.

{
   auto &curConn = CurrConn();
   wxASSERT(!curConn);
 
   curConn = std::move(conn);
   SetFileName(filePath);
}

References CurrConn(), and SetFileName().

Referenced by SaveProject().

Here is the call graph for this function:

Here is the caller graph for this function:

WasCompacted()

bool ProjectFileIO::WasCompacted

(

)

Definition at line 1564 of file ProjectFileIO.cpp.

{
   return mWasCompacted;
}

References mWasCompacted.

Referenced by SetBypass().

Here is the caller graph for this function:

WriteDoc()

bool ProjectFileIO::WriteDoc ( const char *  table, const ProjectSerializer &  autosave, const char *  schema = "main"  )

private

Definition at line 1842 of file ProjectFileIO.cpp.

{
   auto db = DB();
 
   TransactionScope transaction(mProject, "UpdateProject");
 
   int rc;
 
   // For now, we always use an ID of 1. This will replace the previously
   // written row every time.
   char sql[256];
   sqlite3_snprintf(
      sizeof(sql), sql,
      "INSERT INTO %s.%s(id, dict, doc) VALUES(1, ?1, ?2)"
      "       ON CONFLICT(id) DO UPDATE SET dict = ?1, doc = ?2;",
      schema, table);
 
   sqlite3_stmt *stmt = nullptr;
   auto cleanup = finally([&]
   {
      if (stmt)
      {
         sqlite3_finalize(stmt);
      }
   });
 
   rc = sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);
   if (rc != SQLITE_OK)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.query", sql);
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::WriteDoc::prepare");
 
      SetDBError(
         XO("Unable to prepare project file command:\n\n%s").Format(sql)
      );
      return false;
   }
 
   const MemoryStream& dict = autosave.GetDict();
   const MemoryStream& data = autosave.GetData();
 
   // Bind statement parameters
   // Might return SQL_MISUSE which means it's our mistake that we violated
   // preconditions; should return SQL_OK which is 0
   if (
      sqlite3_bind_zeroblob(stmt, 1, dict.GetSize()) ||
      sqlite3_bind_zeroblob(stmt, 2, data.GetSize()))
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.query", sql);
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::WriteDoc::bind");
 
      SetDBError(XO("Unable to bind to blob"));
      return false;
   }
 
   const auto reportError = [this](auto sql) {
      SetDBError(
         XO("Failed to update the project file.\nThe following command failed:\n\n%s")
            .Format(sql));
   };
 
   rc = sqlite3_step(stmt);
 
   if (rc != SQLITE_DONE)
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.query", sql);
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(rc));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::WriteDoc::step");
 
      reportError(sql);
      return false;
   }
 
   // Finalize the statement before committing the transaction
   sqlite3_finalize(stmt);
   stmt = nullptr;
 
   // Get rowid
 
   int64_t rowID = 0;
 
   const wxString rowIDSql =
      wxString::Format("SELECT ROWID FROM %s.%s WHERE id = 1;", schema, table);
 
   if (!GetValue(rowIDSql, rowID, true))
   {
      ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(sqlite3_errcode(db)));
      ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::WriteDoc::rowid");
 
      reportError(rowIDSql);
      return false;
   }
 
   const auto writeStream = [db, schema, table, rowID, this](const char* column, const MemoryStream& stream) {
 
      auto blobStream =
         SQLiteBlobStream::Open(db, schema, table, column, rowID, false);
 
      if (!blobStream)
      {
         ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(sqlite3_errcode(db)));
         ADD_EXCEPTION_CONTEXT("sqlite3.col", column);
         ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::WriteDoc::openBlobStream");
 
         SetDBError(XO("Unable to bind to blob"));
         return false;
      }
 
      for (auto chunk : stream)
      {
         if (SQLITE_OK != blobStream->Write(chunk.first, chunk.second))
         {
            ADD_EXCEPTION_CONTEXT("sqlite3.rc", std::to_string(sqlite3_errcode(db)));
            ADD_EXCEPTION_CONTEXT("sqlite3.col", column);
            ADD_EXCEPTION_CONTEXT("sqlite3.context", "ProjectGileIO::WriteDoc::writeBlobStream");
            // The user visible message is not changed, so there is no need for new strings
            SetDBError(XO("Unable to bind to blob"));
            return false;
         }
      }
 
      if (blobStream->Close() != SQLITE_OK)
      {
         ADD_EXCEPTION_CONTEXT(
            "sqlite3.rc", std::to_string(sqlite3_errcode(db)));
         ADD_EXCEPTION_CONTEXT("sqlite3.col", column);
         ADD_EXCEPTION_CONTEXT(
            "sqlite3.context", "ProjectGileIO::WriteDoc::writeBlobStream");
         // The user visible message is not changed, so there is no need for new
         // strings
         SetDBError(XO("Unable to bind to blob"));
         return false;
      }
 
      return true;
   };
 
   if (!writeStream("dict", dict))
      return false;
 
   if (!writeStream("doc", data))
      return false;
 
   const auto requiredVersion =
      ProjectFormatExtensionsRegistry::Get().GetRequiredVersion(mProject);
 
   const wxString setVersionSql =
      wxString::Format("PRAGMA user_version = %u", requiredVersion.GetPacked());
 
   if (!Query(setVersionSql.c_str(), [](auto...) { return 0; }))
   {
      // DV: Very unlikely case.
      // Since we need to improve the error messages in the future, let's use
      // the generic message for now, so no new strings are needed
      reportError(setVersionSql);
      return false;
   }
 
   return transaction.Commit();
}

References ADD_EXCEPTION_CONTEXT, TransactionScope::Commit(), DB(), ProjectFormatExtensionsRegistry::Get(), ProjectSerializer::GetData(), ProjectSerializer::GetDict(), ProjectFormatExtensionsRegistry::GetRequiredVersion(), MemoryStream::GetSize(), GetValue(), mProject, SQLiteBlobStream::Open(), Query(), SetDBError(), and XO().

Referenced by AutoSave(), CopyTo(), and UpdateSaved().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteXML()

void ProjectFileIO::WriteXML ( XMLWriter &  xmlFile, bool  recording = false, const TrackList *  tracks = nullptr  )

private

Definition at line 1758 of file ProjectFileIO.cpp.

{
   auto &proj = mProject;
   auto &tracklist = tracks ? *tracks : TrackList::Get(proj);
 
   //TIMER_START( "AudacityProject::WriteXML", xml_writer_timer );
 
   xmlFile.StartTag(wxT("project"));
   xmlFile.WriteAttr(wxT("xmlns"), wxT("http://audacity.sourceforge.net/xml/"));
 
   xmlFile.WriteAttr(wxT("version"), wxT(AUDACITY_FILE_FORMAT_VERSION));
   xmlFile.WriteAttr(wxT("audacityversion"), AUDACITY_VERSION_STRING);
 
   ProjectFileIORegistry::Get().CallWriters(proj, xmlFile);
 
   tracklist.Any().Visit([&](const Track *t)
   {
      auto useTrack = t;
      if ( recording ) {
         // When append-recording, there is a temporary "shadow" track accumulating
         // changes and displayed on the screen but it is not yet part of the
         // regular track list.  That is the one that we want to back up.
         // SubstitutePendingChangedTrack() fetches the shadow, if the track has
         // one, else it gives the same track back.
         useTrack = t->SubstitutePendingChangedTrack().get();
      }
      else if ( useTrack->GetId() == TrackId{} ) {
         // This is a track added during a non-appending recording that is
         // not yet in the undo history.  The UndoManager skips backing it up
         // when pushing.  Don't auto-save it.
         return;
      }
      useTrack->WriteXML(xmlFile);
   });
 
   xmlFile.EndTag(wxT("project"));
 
   //TIMER_STOP( xml_writer_timer );
}

References AUDACITY_FILE_FORMAT_VERSION, XMLMethodRegistry< Host >::CallWriters(), XMLWriter::EndTag(), XMLMethodRegistry< Host >::Get(), TrackList::Get(), mProject, XMLWriter::StartTag(), Track::SubstitutePendingChangedTrack(), XMLWriter::WriteAttr(), and wxT().

Referenced by AutoSave(), CopyTo(), GenerateDoc(), and UpdateSaved().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteXMLHeader()

void ProjectFileIO::WriteXMLHeader ( XMLWriter &  xmlFile ) const

private

Definition at line 1743 of file ProjectFileIO.cpp.

{
   xmlFile.Write(wxT("<?xml "));
   xmlFile.Write(wxT("version=\"1.0\" "));
   xmlFile.Write(wxT("standalone=\"no\" "));
   xmlFile.Write(wxT("?>\n"));
 
   xmlFile.Write(wxT("<!DOCTYPE "));
   xmlFile.Write(wxT("project "));
   xmlFile.Write(wxT("PUBLIC "));
   xmlFile.Write(wxT("\"-//audacityproject-1.3.0//DTD//EN\" "));
   xmlFile.Write(wxT("\"http://audacity.sourceforge.net/xml/audacityproject-1.3.0.dtd\" "));
   xmlFile.Write(wxT(">\n"));
}

References XMLWriter::Write(), and wxT().

Referenced by AutoSave(), CopyTo(), GenerateDoc(), and UpdateSaved().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mFileName

FilePath ProjectFileIO::mFileName

private

Definition at line 297 of file ProjectFileIO.h.

Referenced by CloseProject(), Compact(), GetFileName(), GetFreeDiskSpace(), ReopenProject(), SaveConnection(), SaveProject(), and SetFileName().

mHadUnused

bool ProjectFileIO::mHadUnused

private

Definition at line 312 of file ProjectFileIO.h.

Referenced by Compact(), HadUnused(), and ShouldCompact().

mModified

bool ProjectFileIO::mModified

private

Definition at line 303 of file ProjectFileIO.h.

Referenced by AutoSave(), AutoSaveDelete(), IsModified(), LoadProject(), ProjectFileIO(), and SaveProject().

mpErrors

std::shared_ptr<DBConnectionErrors> ProjectFileIO::mpErrors

private

Definition at line 294 of file ProjectFileIO.h.

Referenced by GetLastError(), GetLastErrorCode(), GetLastLog(), GetLibraryError(), OpenConnection(), and SaveProject().

mPrevConn

Connection ProjectFileIO::mPrevConn

private

Definition at line 314 of file ProjectFileIO.h.

Referenced by DiscardConnection(), ProjectFileIO(), RestoreConnection(), and SaveConnection().

mPrevFileName

FilePath ProjectFileIO::mPrevFileName

private

Definition at line 315 of file ProjectFileIO.h.

Referenced by DiscardConnection(), RestoreConnection(), and SaveConnection().

mPrevTemporary

bool ProjectFileIO::mPrevTemporary

private

Definition at line 316 of file ProjectFileIO.h.

Referenced by DiscardConnection(), RestoreConnection(), and SaveConnection().

mProject

AudacityProject& ProjectFileIO::mProject

private

Definition at line 290 of file ProjectFileIO.h.

Referenced by CopyTo(), CurrConn(), GenerateDoc(), HandleXMLChild(), HandleXMLTag(), HasConnection(), LoadProject(), OpenConnection(), RenameOrWarn(), SaveCopy(), SaveProject(), SetFileName(), SetProjectTitle(), WriteDoc(), and WriteXML().

mRecovered

bool ProjectFileIO::mRecovered

private

Definition at line 300 of file ProjectFileIO.h.

Referenced by DeleteBlocks(), IsRecovered(), LoadProject(), ProjectFileIO(), SaveProject(), and SetProjectTitle().

mTemporary

bool ProjectFileIO::mTemporary

private

Definition at line 306 of file ProjectFileIO.h.

Referenced by IsTemporary(), LoadProject(), OpenConnection(), ProjectFileIO(), RestoreConnection(), SaveConnection(), and SaveProject().

mTitle

wxString ProjectFileIO::mTitle

private

Definition at line 292 of file ProjectFileIO.h.

Referenced by SetProjectTitle().

mWasCompacted

bool ProjectFileIO::mWasCompacted

private

Definition at line 309 of file ProjectFileIO.h.

Referenced by Compact(), and WasCompacted().

---

The documentation for this class was generated from the following files:

• ProjectFileIO.h
• ProjectFileIO.cpp