Exporter Class Reference

#include <Export.h>

Inheritance diagram for Exporter:

Collaboration diagram for Exporter:

Classes
struct	ExporterItem
struct	RegisteredExportPlugin

Public Types
using	ExportPluginFactory = std::function< std::unique_ptr< ExportPlugin >() >

Public Member Functions
	Exporter (AudacityProject &project)
virtual	~Exporter ()
void	SetFileDialogTitle (const TranslatableString &DialogTitle)
void	SetDefaultFormat (const FileExtension &Format)
bool	Process (bool selectedOnly, double t0, double t1)
bool	Process (unsigned numChannels, const FileExtension &type, const wxString &filename, bool selectedOnly, double t0, double t1)
bool	Process (unsigned numChannels, const FileExtension &type, const wxString &filename, bool selectedOnly, double t0, double t1, std::unique_ptr< BasicUI::ProgressDialog > &progressDialog)
void	DisplayOptions (int index)
int	FindFormatIndex (int exportindex)
const ExportPluginArray &	GetPlugins ()
bool	ProcessFromTimerRecording (bool selectedOnly, double t0, double t1, wxFileName fnFile, int iFormat, int iSubFormat, int iFilterIndex)
bool	SetAutoExportOptions ()
int	GetAutoExportFormat ()
int	GetAutoExportSubFormat ()
int	GetAutoExportFilterIndex ()
wxFileName	GetAutoExportFileName ()
void	OnExtensionChanged (wxCommandEvent &evt)
void	OnHelp (wxCommandEvent &evt)

Private Member Functions
bool	ExamineTracks ()
bool	GetFilename ()
bool	CheckFilename ()
bool	CheckMix (bool prompt=true)
bool	ExportTracks (std::unique_ptr< BasicUI::ProgressDialog > &progressDialog)
void	CreateUserPane (wxWindow *parent)
void	OnFilterChanged (wxFileCtrlEvent &evt)

Static Private Member Functions
static void	CreateUserPaneCallback (wxWindow *parent, wxUIntPtr userdata)

Private Attributes
FileExtension	mFormatName
FileDialogWrapper *	mDialog
TranslatableString	mFileDialogTitle
AudacityProject *	mProject
std::unique_ptr< MixerSpec >	mMixerSpec
ExportPluginArray	mPlugins
wxFileName	mFilename
wxFileName	mActualName
double	mT0
double	mT1
int	mFilterIndex
int	mFormat
int	mSubFormat
int	mNumSelected {}
bool	mMono {}
unsigned	mNumMono
unsigned	mChannels
bool	mSelectedOnly
wxSimplebook *	mBook

Detailed Description

Definition at line 171 of file Export.h.

Member Typedef Documentation

ExportPluginFactory

using Exporter::ExportPluginFactory = std::function< std::unique_ptr< ExportPlugin >() >

Definition at line 176 of file Export.h.

Constructor & Destructor Documentation

Exporter()

Exporter::Exporter

(

AudacityProject &

project

)

Definition at line 324 of file Export.cpp.

: mProject{ &project }
{
   using namespace Registry;
   static OrderingPreferenceInitializer init{
      PathStart,
      { {wxT(""), wxT("PCM,MP3,OGG,FLAC,MP2,CommandLine,FFmpeg") } },
   };
 
   mMixerSpec = NULL;
   mBook = NULL;
 
   // build the list of export plugins.
   for ( const auto &factory : sFactories() )
      mPlugins.emplace_back( factory() );
 
   struct MyVisitor final : Visitor {
      MyVisitor()
      {
         // visit the registry to collect the plug-ins properly
         // sorted
         GroupItem<Registry::DefaultTraits> top{ PathStart };
         Registry::Visit( *this, &top, &ExporterItem::Registry() );
      }
 
      void Visit( SingleItem &item, const Path &path ) override
      {
         mPlugins.emplace_back(
            static_cast<ExporterItem&>( item ).mFactory() );
      }
 
      ExportPluginArray mPlugins;
   } visitor;
 
   mPlugins.swap( visitor.mPlugins );
 
   SetFileDialogTitle( XO("Export Audio") );
}

References cloud::factory, mBook, mMixerSpec, mPlugins, anonymous_namespace{Export.cpp}::PathStart, Exporter::ExporterItem::Registry(), SetFileDialogTitle(), anonymous_namespace{Export.cpp}::sFactories(), Registry::Visit(), wxT(), and XO().

Here is the call graph for this function:

~Exporter()

Exporter::~Exporter ( )

virtual

Definition at line 363 of file Export.cpp.

{
}

Member Function Documentation

CheckFilename()

bool Exporter::CheckFilename ( )

private

Definition at line 748 of file Export.cpp.

{
   //
   // To be even safer, return a temporary file name based
   // on this one...
   //
 
   mActualName = mFilename;
 
   int suffix = 0;
   while (mFilename.FileExists()) {
      mFilename.SetName(mActualName.GetName() +
                        wxString::Format(wxT("%d"), suffix));
      suffix++;
   }
 
   return true;
}

References mActualName, mFilename, and wxT().

Referenced by Process(), and ProcessFromTimerRecording().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckMix()

bool Exporter::CheckMix ( bool  prompt = true )

private

Definition at line 797 of file Export.cpp.

{
   // Clean up ... should never happen
   mMixerSpec.reset();
 
   // Determine if exported file will be stereo or mono or multichannel,
   // and if mixing will occur.
 
   auto downMix = ImportExportPrefs::ExportDownMixSetting.ReadEnum();
   int exportedChannels = mPlugins[mFormat]->SetNumExportChannels();
 
   if (downMix) {
      unsigned channels = mMono ? 1 : 2;
      mChannels =
         std::min(channels, mPlugins[mFormat]->GetMaxChannels(mSubFormat));
 
      if (mNumSelected > 1 || channels > mChannels) {
         // May give a message about mixing-down
         wxString exportFormat = mPlugins[mFormat]->GetFormat(mSubFormat);
         if (exportFormat != wxT("CL") && exportFormat != wxT("FFMPEG") && exportedChannels == -1)
            exportedChannels = mChannels;
 
         if (prompt) {
            auto pWindow = ProjectWindow::Find(mProject);
            if (exportedChannels == 1) {
               if (ShowWarningDialog(pWindow,
                  wxT("MixMono"),
                  XO("Your tracks will be mixed down and exported as one mono file."),
                  true) == wxID_CANCEL)
                  return false;
            }
            else if (exportedChannels == 2) {
               if (ShowWarningDialog(pWindow,
                  wxT("MixStereo"),
                  XO("Your tracks will be mixed down and exported as one stereo file."),
                  true) == wxID_CANCEL)
                  return false;
            }
            else {
               if (ShowWarningDialog(pWindow,
                  wxT("MixUnknownChannels"),
                  XO("Your tracks will be mixed down to one exported file according to the encoder settings."),
                  true) == wxID_CANCEL)
                  return false;
            }
         }
      }
   }
   else
   {
      if (exportedChannels < 0)
         exportedChannels = mPlugins[mFormat]->GetMaxChannels(mSubFormat);
 
      ExportMixerDialog md(&TrackList::Get( *mProject ),
                           mSelectedOnly,
                           exportedChannels,
                           NULL,
                           1,
                           XO("Advanced Mixing Options"));
      if (prompt) {
         if (md.ShowModal() != wxID_OK) {
            return false;
         }
      }
 
      mMixerSpec = std::make_unique<MixerSpec>(*(md.GetMixerSpec()));
      mChannels = mMixerSpec->GetNumChannels();
   }
 
   return true;
}

References ImportExportPrefs::ExportDownMixSetting, ProjectWindow::Find(), TrackList::Get(), ExportMixerDialog::GetMixerSpec(), mChannels, mFormat, min(), mMixerSpec, mMono, mNumSelected, mPlugins, mProject, mSelectedOnly, mSubFormat, EnumSetting< Enum >::ReadEnum(), ShowWarningDialog(), wxT(), and XO().

Referenced by Process(), and ProcessFromTimerRecording().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateUserPane()

void Exporter::CreateUserPane ( wxWindow *  parent )

private

Definition at line 925 of file Export.cpp.

{
   ShuttleGui S(parent, eIsCreating);
 
   S.StartStatic(XO("Format Options"), 1);
   {
      S.StartHorizontalLay(wxEXPAND);
      {
         mBook = S.Position(wxEXPAND).StartSimplebook();
         {
            for (const auto &pPlugin : mPlugins)
            {
               for (int j = 0; j < pPlugin->GetFormatCount(); j++)
               {
                  // Name of simple book page is not displayed
                  S.StartNotebookPage( {} );
                  {
                     pPlugin->OptionsCreate(S, j);
                  }
                  S.EndNotebookPage();
               }
            }
         }
         S.EndSimplebook();
 
         auto b = safenew wxBitmapButton(S.GetParent(), wxID_HELP, theTheme.Bitmap( bmpHelpIcon ));
         b->SetToolTip( XO("Help").Translation() );
         b->SetLabel(XO("Help").Translation());       // for screen readers
         S.Position(wxALIGN_BOTTOM | wxRIGHT | wxBOTTOM).AddWindow(b);
      }
      S.EndHorizontalLay();
   }
   S.EndStatic();
 
   return;
}

References ThemeBase::Bitmap(), eIsCreating, mBook, mPlugins, S, safenew, theTheme, and XO().

Referenced by CreateUserPaneCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateUserPaneCallback()

void Exporter::CreateUserPaneCallback ( wxWindow *  parent, wxUIntPtr  userdata  )

staticprivate

Definition at line 916 of file Export.cpp.

{
   Exporter *self = (Exporter *) userdata;
   if (self)
   {
      self->CreateUserPane(parent);
   }
}

References CreateUserPane().

Referenced by GetFilename().

Here is the call graph for this function:

Here is the caller graph for this function:

DisplayOptions()

void Exporter::DisplayOptions

(

int

index

)

Definition at line 767 of file Export.cpp.

{
   int c = 0;
   int mf = -1, msf = -1;
   int i = -1;
   for (const auto &pPlugin : mPlugins)
   {
      ++i;
      for (int j = 0; j < pPlugin->GetFormatCount(); j++)
      {
         if (index == c)
         {
            mf = i;
            msf = j;
         }
         c++;
      }
   }
   // This shouldn't happen...
   if (index >= c) {
      return;
   }
 
#if defined(__WXMSW__)
   mPlugins[mf]->DisplayOptions( FindProjectFrame( mProject ), msf);
#else
   mPlugins[mf]->DisplayOptions(mDialog, msf);
#endif
}

References FindProjectFrame(), mDialog, mPlugins, and mProject.

Here is the call graph for this function:

ExamineTracks()

bool Exporter::ExamineTracks ( )

private

Definition at line 496 of file Export.cpp.

{
   // Init
   mNumSelected = 0;
 
   // First analyze the selected audio, perform sanity checks, and provide
   // information as appropriate.
 
   // Tally how many are right, left, mono, and make sure at
   // least one track is selected (if selectedOnly==true)
 
   double earliestBegin = mT1;
   double latestEnd = mT0;
 
   auto &tracks = TrackList::Get(*mProject);
 
   bool anySolo =
      !(tracks.Leaders<const WaveTrack>() + &WaveTrack::GetSolo).empty();
 
   const auto range = tracks.Leaders<const WaveTrack>()
      + (mSelectedOnly ? &Track::IsSelected : &Track::Any)
      - (anySolo ? &WaveTrack::GetNotSolo : &WaveTrack::GetMute);
 
   mMono = std::all_of(range.begin(), range.end(), [](const WaveTrack *pTrack){
      return IsMono(*pTrack) && pTrack->GetPan() == 0.0;
   });
 
   for (auto tr : range) {
      mNumSelected++;
 
      if (tr->GetOffset() < earliestBegin) {
         earliestBegin = tr->GetOffset();
      }
 
      if (tr->GetEndTime() > latestEnd) {
         latestEnd = tr->GetEndTime();
      }
   }
 
   if (mNumSelected == 0) {
      TranslatableString message;
      if(mSelectedOnly)
         message = XO("All selected audio is muted.");
      else
         message = XO("All audio is muted.");
      ShowExportErrorDialog(
         ":576",
         message, AudacityExportCaptionStr(), false);
      return false;
   }
 
   // The skipping of silent space could be cleverer and take 
   // into account clips.
   // As implemented now, it can only skip initial silent space that 
   // has no clip before it, and terminal silent space that has no clip 
   // after it.
   if (mT0 < earliestBegin){
      // Bug 1904 
      // Previously we always skipped initial silent space.
      // Now skipping it is an opt-in option.
      bool skipSilenceAtBeginning;
      gPrefs->Read(wxT("/AudioFiles/SkipSilenceAtBeginning"),
                                      &skipSilenceAtBeginning, false);
      if (skipSilenceAtBeginning)
         mT0 = earliestBegin;
   }
 
   // We still skip silent space at the end
   if (mT1 > latestEnd)
      mT1 = latestEnd;
 
   return true;
}

References Track::Any(), AudacityExportCaptionStr(), TrackList::Get(), WaveTrack::GetMute(), PlayableTrack::GetNotSolo(), WaveTrack::GetSolo(), gPrefs, Track::IsSelected(), mMono, mNumSelected, mProject, mSelectedOnly, mT0, mT1, ShowExportErrorDialog(), tracks, wxT(), and XO().

Referenced by Process(), and ProcessFromTimerRecording().

Here is the call graph for this function:

Here is the caller graph for this function:

ExportTracks()

bool Exporter::ExportTracks ( std::unique_ptr< BasicUI::ProgressDialog > &  progressDialog )

private

Definition at line 869 of file Export.cpp.

{
   // Keep original in case of failure
   if (mActualName != mFilename) {
      ::wxRenameFile(mActualName.GetFullPath(), mFilename.GetFullPath());
   }
 
   bool success = false;
 
   auto cleanup = finally( [&] {
      if (mActualName != mFilename) {
         // Remove backup
         if ( success )
            ::wxRemoveFile(mFilename.GetFullPath());
         else {
            // Restore original, if needed
            ::wxRemoveFile(mActualName.GetFullPath());
            ::wxRenameFile(mFilename.GetFullPath(), mActualName.GetFullPath());
         }
         // Restore filename
         mFilename = mActualName;
      }
      else {
         if ( ! success )
            // Remove any new, and only partially written, file.
            ::wxRemoveFile(mFilename.GetFullPath());
      }
   } );
 
   auto result = mPlugins[mFormat]->Export(mProject,
                                       progressDialog,
                                       mChannels,
                                       mActualName.GetFullPath(),
                                       mSelectedOnly,
                                       mT0,
                                       mT1,
                                       mMixerSpec.get(),
                                       NULL,
                                       mSubFormat);
 
   success =
      result == ProgressResult::Success || result == ProgressResult::Stopped;
 
   return success;
}

References mActualName, mChannels, mFilename, mFormat, mMixerSpec, mPlugins, mProject, mSelectedOnly, mSubFormat, mT0, mT1, and BasicUI::Success.

Referenced by Process(), and ProcessFromTimerRecording().

Here is the caller graph for this function:

FindFormatIndex()

int Exporter::FindFormatIndex

(

int

exportindex

)

Definition at line 384 of file Export.cpp.

{
   int c = 0;
   for (const auto &pPlugin : mPlugins)
   {
      for (int j = 0; j < pPlugin->GetFormatCount(); j++)
      {
         if (exportindex == c) return j;
         c++;
      }
   }
   return 0;
}

References mPlugins.

GetAutoExportFileName()

wxFileName Exporter::GetAutoExportFileName

(

)

Definition at line 1056 of file Export.cpp.

                                           {
   return mFilename;
}

References mFilename.

GetAutoExportFilterIndex()

int Exporter::GetAutoExportFilterIndex

(

)

Definition at line 1052 of file Export.cpp.

                                       {
   return mFormat;
}

References mFormat.

GetAutoExportFormat()

int Exporter::GetAutoExportFormat

(

)

Definition at line 1044 of file Export.cpp.

                                  {
   return mFormat;
}

References mFormat.

GetAutoExportSubFormat()

int Exporter::GetAutoExportSubFormat

(

)

Definition at line 1048 of file Export.cpp.

                                     {
   return mSubFormat;
}

References mSubFormat.

GetFilename()

bool Exporter::GetFilename ( )

private

Definition at line 570 of file Export.cpp.

{
   mFormat = -1;
 
   FileNames::FileTypes fileTypes;
   auto defaultFormat = mFormatName;
   if( defaultFormat.empty() )
      defaultFormat = gPrefs->Read(wxT("/Export/Format"),
                                         wxT("WAV"));
 
   mFilterIndex = 0;
 
   {
      int i = -1;
      for (const auto &pPlugin : mPlugins) {
         ++i;
         for (int j = 0; j < pPlugin->GetFormatCount(); j++)
         {
            auto mask = pPlugin->GetMask(j);
            fileTypes.insert( fileTypes.end(), mask.begin(), mask.end() );
            if (mPlugins[i]->GetFormat(j) == defaultFormat) {
               mFormat = i;
               mSubFormat = j;
            }
            if (mFormat == -1) mFilterIndex++;
         }
      }
   }
   if (mFormat == -1)
   {
      mFormat = 0;
      mFilterIndex = 0;
      mSubFormat = 0;
   }
   wxString defext = mPlugins[mFormat]->GetExtension(mSubFormat).Lower();
 
   //Bug 1304: Set a default path if none was given.  For Export.
   mFilename.SetPath(FileNames::FindDefaultPath(FileNames::Operation::Export));
   mFilename.SetName(mProject->GetProjectName());
   if (mFilename.GetName().empty())
      mFilename.SetName(_("untitled"));
   while (true) {
      // Must reset each iteration
      mBook = NULL;
 
      {
         auto useFileName = mFilename;
         if (!useFileName.HasExt())
            useFileName.SetExt(defext);
         FileDialogWrapper fd( ProjectWindow::Find( mProject ),
                       mFileDialogTitle,
                       mFilename.GetPath(),
                       useFileName.GetFullName(),
                       fileTypes,
                       wxFD_SAVE | wxRESIZE_BORDER);
         mDialog = &fd;
         mDialog->PushEventHandler(this);
 
         fd.SetUserPaneCreator(CreateUserPaneCallback, (wxUIntPtr) this);
         fd.SetFilterIndex(mFilterIndex);
 
         int result = fd.ShowModal();
 
         mDialog->PopEventHandler();
 
         if (result == wxID_CANCEL) {
            return false;
         }
 
         mFilename = fd.GetPath();
         if (mFilename == wxT("")) {
            return false;
         }
 
         mFormat = fd.GetFilterIndex();
         mFilterIndex = fd.GetFilterIndex();
      }
 
      {
         int c = 0;
         int i = -1;
         for (const auto &pPlugin : mPlugins)
         {
            ++i;
            for (int j = 0; j < pPlugin->GetFormatCount(); j++)
            {
               if (mFilterIndex == c)
               {
                  mFormat = i;
                  mSubFormat = j;
               }
               c++;
            }
         }
      }
 
      const auto ext = mFilename.GetExt();
      defext = mPlugins[mFormat]->GetExtension(mSubFormat).Lower();
 
      //
      // Check the extension - add the default if it's not there,
      // and warn user if it's abnormal.
      //
      if (ext.empty()) {
         //
         // Make sure the user doesn't accidentally save the file
         // as an extension with no name, like just plain ".wav".
         //
         if (mFilename.GetName().Left(1) == wxT(".")) {
            auto prompt =
               XO("Are you sure you want to export the file as \"%s\"?\n")
                  .Format( mFilename.GetFullName() );
 
            int action = AudacityMessageBox(
               prompt,
               XO("Warning"),
               wxYES_NO | wxICON_EXCLAMATION);
            if (action != wxYES) {
               continue;
            }
         }
 
         mFilename.SetExt(defext);
      }
 
      if (!mPlugins[mFormat]->CheckFileName(mFilename, mSubFormat))
      {
         continue;
      }
      else if (!ext.empty() && !mPlugins[mFormat]->IsExtension(ext,mSubFormat) && ext.CmpNoCase(defext)) {
         auto prompt = XO("You are about to export a %s file with the name \"%s\".\n\nNormally these files end in \".%s\", and some programs will not open files with nonstandard extensions.\n\nAre you sure you want to export the file under this name?")
               .Format(mPlugins[mFormat]->GetFormat(mSubFormat),
                       mFilename.GetFullName(),
                       defext);
 
         int action = AudacityMessageBox(
            prompt,
            XO("Warning"),
            wxYES_NO | wxICON_EXCLAMATION);
         if (action != wxYES) {
            continue;
         }
      }
 
      if (mFilename.GetFullPath().length() >= 256) {
         AudacityMessageBox(
            XO( "Sorry, pathnames longer than 256 characters not supported.") );
         continue;
      }
 
// For Mac, it's handled by the FileDialog
#if !defined(__WXMAC__)
      if (mFilename.FileExists()) {
         auto prompt = XO("A file named \"%s\" already exists. Replace?")
            .Format( mFilename.GetFullPath() );
 
         int action = AudacityMessageBox(
            prompt,
            XO("Warning"),
            wxYES_NO | wxICON_EXCLAMATION);
         if (action != wxYES) {
            continue;
         }
      }
#endif
 
      break;
   }
 
   return true;
}

References _, AudacityMessageBox(), CreateUserPaneCallback(), ProjectWindow::Find(), FileNames::FindDefaultPath(), FileDialog::GetFilterIndex(), FileDialog::GetPath(), AudacityProject::GetProjectName(), gPrefs, mBook, mDialog, mFileDialogTitle, mFilename, mFilterIndex, mFormat, mFormatName, mPlugins, mProject, mSubFormat, FileDialog::SetFilterIndex(), FileDialogBase::SetUserPaneCreator(), FileDialog::ShowModal(), wxT(), and XO().

Referenced by Process(), and SetAutoExportOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPlugins()

const ExportPluginArray & Exporter::GetPlugins

(

)

Definition at line 398 of file Export.cpp.

{
   return mPlugins;
}

References mPlugins.

OnExtensionChanged()

void Exporter::OnExtensionChanged

(

wxCommandEvent &

evt

)

Definition at line 367 of file Export.cpp.

{
   mDialog->SetFileExtension(evt.GetString().BeforeFirst(' ').Lower());
}

References mDialog, and FileDialog::SetFileExtension().

Here is the call graph for this function:

OnFilterChanged()

void Exporter::OnFilterChanged ( wxFileCtrlEvent &  evt )

private

Definition at line 962 of file Export.cpp.

{
   int index = evt.GetFilterIndex();
 
   // On GTK, this event can fire before the userpane is created
   if (mBook == NULL || index < 0 || index >= (int) mBook->GetPageCount())
   {
      return;
   }
 
#if defined(__WXGTK__)
   // On Windows and MacOS, changing the filter in the dialog
   // automatically changes the extension of the current file
   // name. GTK doesn't, so do it here.
   {
      FileNames::FileTypes fileTypes;
 
      int i = -1;
      for (const auto &pPlugin : mPlugins)
      {
         ++i;
         for (int j = 0; j < pPlugin->GetFormatCount(); j++)
         {
            auto mask = pPlugin->GetMask(j);
            fileTypes.insert( fileTypes.end(), mask.begin(), mask.end() );
         }
      }
 
      if (index < fileTypes.size())
      {
         mDialog->SetFileExtension(fileTypes[index].extensions[0].Lower());
      }
   }
#endif
 
   mBook->ChangeSelection(index);
}

References mBook, mDialog, mPlugins, and FileDialog::SetFileExtension().

Here is the call graph for this function:

OnHelp()

void Exporter::OnHelp

(

wxCommandEvent &

evt

)

Definition at line 372 of file Export.cpp.

{
   wxWindow * pWin = FindProjectFrame( mProject );
   HelpSystem::ShowHelp(pWin, L"File_Export_Dialog", true);
}

References FindProjectFrame(), mProject, and HelpSystem::ShowHelp().

Here is the call graph for this function:

Process() [1/3]

bool Exporter::Process	(	bool	selectedOnly,
		double	t0,
		double	t1
	)

Definition at line 403 of file Export.cpp.

{
   // Save parms
   mSelectedOnly = selectedOnly;
   mT0 = t0;
   mT1 = t1;
 
   // Gather track information
   if (!ExamineTracks()) {
      return false;
   }
 
   // Ask user for file name
   if (!GetFilename()) {
      return false;
   }
 
   // Check for down mixing
   if (!CheckMix()) {
      return false;
   }
 
   // Let user edit MetaData
   if (mPlugins[mFormat]->GetCanMetaData(mSubFormat)) {
      if (!TagsEditorDialog::DoEditMetadata( *mProject,
         XO("Edit Metadata Tags"), XO("Exported Tags"),
         ProjectSettings::Get( *mProject ).GetShowId3Dialog())) {
         return false;
      }
   }
 
   // Ensure filename doesn't interfere with project files.
   if (!CheckFilename()) {
      return false;
   }
 
   // Export the tracks
   std::unique_ptr<BasicUI::ProgressDialog> pDialog;
   bool success = ExportTracks(pDialog);
 
   // Get rid of mixerspec
   mMixerSpec.reset();
 
   if (success) {
      if (mFormatName.empty()) {
         gPrefs->Write(wxT("/Export/Format"), mPlugins[mFormat]->GetFormat(mSubFormat));
      }
 
      FileNames::UpdateDefaultPath(FileNames::Operation::Export, mFilename.GetPath());
   }
 
   return success;
}

References CheckFilename(), CheckMix(), TagsEditorDialog::DoEditMetadata(), ExamineTracks(), ExportTracks(), ProjectSettings::Get(), GetFilename(), ProjectSettings::GetShowId3Dialog(), gPrefs, mFilename, mFormat, mFormatName, mMixerSpec, mPlugins, mProject, mSelectedOnly, mSubFormat, mT0, mT1, FileNames::UpdateDefaultPath(), wxT(), and XO().

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

Process() [2/3]

bool Exporter::Process	(	unsigned	numChannels,
		const FileExtension &	type,
		const wxString &	filename,
		bool	selectedOnly,
		double	t0,
		double	t1
	)

Definition at line 457 of file Export.cpp.

{
   std::unique_ptr<BasicUI::ProgressDialog> pDialog;
   return Process(numChannels, type, filename, selectedOnly, t0, t1, pDialog);
}

References Process().

Here is the call graph for this function:

Process() [3/3]

bool Exporter::Process	(	unsigned	numChannels,
		const FileExtension &	type,
		const wxString &	filename,
		bool	selectedOnly,
		double	t0,
		double	t1,
		std::unique_ptr< BasicUI::ProgressDialog > &	progressDialog
	)

Definition at line 465 of file Export.cpp.

{
   // Save parms
   mChannels = numChannels;
   mFilename = filename;
   mSelectedOnly = selectedOnly;
   mT0 = t0;
   mT1 = t1;
   mActualName = mFilename;
 
   int i = -1;
   for (const auto& pPlugin : mPlugins)
   {
      ++i;
      for (int j = 0; j < pPlugin->GetFormatCount(); j++)
      {
         if (pPlugin->GetFormat(j).IsSameAs(type, false))
         {
            mFormat = i;
            mSubFormat = j;
            return CheckFilename() && ExportTracks(progressDialog);
         }
      }
   }
   
   return false;
}

References CheckFilename(), ExportTracks(), mActualName, mChannels, mFilename, mFormat, mPlugins, mSelectedOnly, mSubFormat, mT0, and mT1.

Here is the call graph for this function:

ProcessFromTimerRecording()

bool Exporter::ProcessFromTimerRecording	(	bool	selectedOnly,
		double	t0,
		double	t1,
		wxFileName	fnFile,
		int	iFormat,
		int	iSubFormat,
		int	iFilterIndex
	)

Definition at line 1000 of file Export.cpp.

{
   // Save parms
   mSelectedOnly = selectedOnly;
   mT0 = t0;
   mT1 = t1;
 
   // Auto Export Parameters
   mFilename = fnFile;
   mFormat = iFormat;
   mSubFormat = iSubFormat;
   mFilterIndex = iFilterIndex;
 
   // Gather track information
   if (!ExamineTracks()) {
      return false;
   }
 
   // Check for down mixing
   if (!CheckMix(false)) {
      return false;
   }
 
   // Ensure filename doesn't interfere with project files.
   if (!CheckFilename()) {
      return false;
   }
 
   // Export the tracks
   std::unique_ptr<BasicUI::ProgressDialog> pDialog;
   bool success = ExportTracks(pDialog);
 
   // Get rid of mixerspec
   mMixerSpec.reset();
 
   return success;
}

References CheckFilename(), CheckMix(), ExamineTracks(), ExportTracks(), mFilename, mFilterIndex, mFormat, mMixerSpec, mSelectedOnly, mSubFormat, mT0, and mT1.

Here is the call graph for this function:

SetAutoExportOptions()

bool Exporter::SetAutoExportOptions

(

)

Definition at line 1060 of file Export.cpp.

                                    {
   mFormat = -1;
 
   if( GetFilename()==false )
        return false;
 
   // Let user edit MetaData
   if (mPlugins[mFormat]->GetCanMetaData(mSubFormat)) {
      if (!TagsEditorDialog::DoEditMetadata( *mProject,
         XO("Edit Metadata Tags"),
         XO("Exported Tags"),
         ProjectSettings::Get(*mProject).GetShowId3Dialog())) {
         return false;
      }
   }
 
   return true;
}

References TagsEditorDialog::DoEditMetadata(), ProjectSettings::Get(), GetFilename(), ProjectSettings::GetShowId3Dialog(), mFormat, mPlugins, mProject, mSubFormat, and XO().

Here is the call graph for this function:

SetDefaultFormat()

void Exporter::SetDefaultFormat ( const FileExtension &  Format )

inline

Definition at line 197 of file Export.h.

{ mFormatName = Format;};

SetFileDialogTitle()

void Exporter::SetFileDialogTitle

(

const TranslatableString &

DialogTitle

)

Definition at line 378 of file Export.cpp.

{
   // The default title is "Export File"
   mFileDialogTitle = DialogTitle;
}

References mFileDialogTitle.

Referenced by Exporter().

Here is the caller graph for this function:

Member Data Documentation

mActualName

wxFileName Exporter::mActualName

private

Definition at line 259 of file Export.h.

Referenced by CheckFilename(), ExportTracks(), and Process().

mBook

wxSimplebook* Exporter::mBook

private

Definition at line 272 of file Export.h.

Referenced by CreateUserPane(), Exporter(), GetFilename(), and OnFilterChanged().

mChannels

unsigned Exporter::mChannels

private

Definition at line 269 of file Export.h.

Referenced by CheckMix(), ExportTracks(), and Process().

mDialog

FileDialogWrapper* Exporter::mDialog

private

Definition at line 251 of file Export.h.

Referenced by DisplayOptions(), GetFilename(), OnExtensionChanged(), and OnFilterChanged().

mFileDialogTitle

TranslatableString Exporter::mFileDialogTitle

private

Definition at line 252 of file Export.h.

Referenced by GetFilename(), and SetFileDialogTitle().

mFilename

wxFileName Exporter::mFilename

private

Definition at line 258 of file Export.h.

Referenced by CheckFilename(), ExportTracks(), GetAutoExportFileName(), GetFilename(), Process(), and ProcessFromTimerRecording().

mFilterIndex

int Exporter::mFilterIndex

private

Definition at line 263 of file Export.h.

Referenced by GetFilename(), and ProcessFromTimerRecording().

mFormat

int Exporter::mFormat

private

Definition at line 264 of file Export.h.

Referenced by CheckMix(), ExportTracks(), GetAutoExportFilterIndex(), GetAutoExportFormat(), GetFilename(), Process(), ProcessFromTimerRecording(), and SetAutoExportOptions().

mFormatName

FileExtension Exporter::mFormatName

private

Definition at line 250 of file Export.h.

Referenced by GetFilename(), and Process().

mMixerSpec

std::unique_ptr<MixerSpec> Exporter::mMixerSpec

private

Definition at line 254 of file Export.h.

Referenced by CheckMix(), Exporter(), ExportTracks(), Process(), and ProcessFromTimerRecording().

mMono

bool Exporter::mMono {}

private

Definition at line 267 of file Export.h.

Referenced by CheckMix(), and ExamineTracks().

mNumMono

unsigned Exporter::mNumMono

private

Definition at line 268 of file Export.h.

mNumSelected

int Exporter::mNumSelected {}

private

Definition at line 266 of file Export.h.

Referenced by CheckMix(), and ExamineTracks().

mPlugins

ExportPluginArray Exporter::mPlugins

private

Definition at line 256 of file Export.h.

Referenced by CheckMix(), CreateUserPane(), DisplayOptions(), Exporter(), ExportTracks(), FindFormatIndex(), GetFilename(), GetPlugins(), OnFilterChanged(), Process(), and SetAutoExportOptions().

mProject

AudacityProject* Exporter::mProject

private

Definition at line 253 of file Export.h.

Referenced by CheckMix(), DisplayOptions(), ExamineTracks(), ExportTracks(), GetFilename(), OnHelp(), Process(), and SetAutoExportOptions().

mSelectedOnly

bool Exporter::mSelectedOnly

private

Definition at line 270 of file Export.h.

Referenced by CheckMix(), ExamineTracks(), ExportTracks(), Process(), and ProcessFromTimerRecording().

mSubFormat

int Exporter::mSubFormat

private

Definition at line 265 of file Export.h.

Referenced by CheckMix(), ExportTracks(), GetAutoExportSubFormat(), GetFilename(), Process(), ProcessFromTimerRecording(), and SetAutoExportOptions().

mT0

double Exporter::mT0

private

Definition at line 261 of file Export.h.

Referenced by ExamineTracks(), ExportTracks(), Process(), and ProcessFromTimerRecording().

mT1

double Exporter::mT1

private

Definition at line 262 of file Export.h.

Referenced by ExamineTracks(), ExportTracks(), Process(), and ProcessFromTimerRecording().

---

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

• Export.h
• Export.cpp