audacity::cloud::audiocom::sync::MixdownUploader Class Reference

#include <MixdownUploader.h>

Inheritance diagram for audacity::cloud::audiocom::sync::MixdownUploader:

Collaboration diagram for audacity::cloud::audiocom::sync::MixdownUploader:

Classes
class	DataExporter
struct	Tag

Public Member Functions
	MixdownUploader (Tag, concurrency::CancellationContextPtr cancellationContext, const ServiceConfig &config, const AudacityProject &project, MixdownProgressCallback progressCallback)
	~MixdownUploader ()
void	SetUrls (const UploadUrls &urls)
std::future< MixdownResult >	GetResultFuture ()
Public Member Functions inherited from audacity::concurrency::ICancellable
virtual	~ICancellable ()=default
virtual void	Cancel ()=0

Static Public Member Functions
static std::shared_ptr< MixdownUploader >	Upload (concurrency::CancellationContextPtr cancellationContext, const ServiceConfig &config, const AudacityProject &project, MixdownProgressCallback progressCallback)

Private Member Functions
void	Cancel ()
void	ReportProgress (MixdownState state, double progress, ResponseResult uploadResult)
void	ExportProject ()
void	UploadMixdown ()

Private Attributes
const ServiceConfig &	mServiceConfig
const AudacityProject &	mProject
std::mutex	mUploadUrlsMutex
std::condition_variable	mUploadUrlsSet
std::optional< UploadUrls >	mUploadUrls
MixdownProgressCallback	mProgressCallback
std::unique_ptr< DataExporter >	mDataExporter
std::string	mExportedFilePath
std::atomic< double >	mProgress {}
bool	mProgressUpdateQueued { false }
std::atomic< bool >	mUploadCancelled { false }
std::atomic< bool >	mFinished { false }
std::promise< MixdownResult >	mPromise
concurrency::CancellationContextPtr	mCancellationContext

Detailed Description

Definition at line 59 of file MixdownUploader.h.

Constructor & Destructor Documentation

MixdownUploader()

audacity::cloud::audiocom::sync::MixdownUploader::MixdownUploader	(	Tag	,
		concurrency::CancellationContextPtr	cancellationContext,
		const ServiceConfig &	config,
		const AudacityProject &	project,
		MixdownProgressCallback	progressCallback
	)

Definition at line 221 of file MixdownUploader.cpp.

    : mServiceConfig { config }
    , mProject { project }
    , mProgressCallback { std::move(progressCallback) }
    , mCancellationContext { std::move(cancellationContext) }
{
   ExportProject();
}

References ExportProject().

Here is the call graph for this function:

~MixdownUploader()

audacity::cloud::audiocom::sync::MixdownUploader::~MixdownUploader

(

)

Definition at line 232 of file MixdownUploader.cpp.

{
   if (wxFileExists(mExportedFilePath))
      wxRemoveFile(mExportedFilePath);
}

References mExportedFilePath.

Member Function Documentation

Cancel()

void audacity::cloud::audiocom::sync::MixdownUploader::Cancel ( )

privatevirtual

Implements audacity::concurrency::ICancellable.

Definition at line 267 of file MixdownUploader.cpp.

{
   if (!mDataExporter)
      return;
 
   if (mUploadCancelled.exchange(true, std::memory_order_acq_rel))
      return;
 
   // To be on a safe side, we cancel both operations
   mDataExporter->Cancel();
   // And ensure that WaitingForUrls is interrupted too
   mUploadUrlsSet.notify_all();
}

References mDataExporter, mUploadCancelled, and mUploadUrlsSet.

ExportProject()

void audacity::cloud::audiocom::sync::MixdownUploader::ExportProject ( )

private

Definition at line 326 of file MixdownUploader.cpp.

{
   if (!HasPlayableTracks(mProject))
   {
      mFinished.store(true);
      mPromise.set_value({ MixdownState::Empty });
      return;
   }
 
   auto& tracks = TrackList::Get(mProject);
 
   const double t0 = 0.0;
   const double t1 = tracks.GetEndTime();
 
   const int nChannels = CalculateChannels(tracks);
 
   auto hasMimeType = [](const auto&& mimeTypes, const std::string& mimeType)
   {
      return std::find(mimeTypes.begin(), mimeTypes.end(), mimeType) !=
             mimeTypes.end();
   };
 
   const auto& registry = ExportPluginRegistry::Get();
 
   for (const auto& preferredMimeType :
        GetServiceConfig().GetPreferredAudioFormats(false))
   {
      auto config = GetServiceConfig().GetExportConfig(preferredMimeType);
 
      ExportProcessor::Parameters parameters;
      auto pluginIt = std::find_if(
         registry.begin(), registry.end(),
         [&](auto t)
         {
            auto [plugin, formatIndex] = t;
            parameters.clear();
            return hasMimeType(
                      plugin->GetMimeTypes(formatIndex), preferredMimeType) &&
                   plugin->ParseConfig(formatIndex, config, parameters);
         });
 
      if (pluginIt == registry.end())
         continue;
 
      const auto [plugin, formatIndex] = *pluginIt;
 
      const auto formatInfo = plugin->GetFormatInfo(formatIndex);
      const auto path       = GenerateTempPath(formatInfo.extensions[0]);
 
      if (path.empty())
         continue;
 
      auto builder = ExportTaskBuilder {}
                        .SetParameters(parameters)
                        .SetNumChannels(nChannels)
                        .SetSampleRate(ProjectRate::Get(mProject).GetRate())
                        .SetPlugin(plugin)
                        .SetFileName(audacity::ToWXString(path))
                        .SetRange(t0, t1, false);
 
      mExportedFilePath = path;
 
      mDataExporter = std::make_unique<DataExporter>(
         *this, builder.Build(const_cast<AudacityProject&>(mProject)));
 
      return;
   }
 
   if (!mDataExporter)
   {
      mFinished.store(true);
      mPromise.set_value({ MixdownState::Failed });
   }
}

References audacity::cloud::audiocom::sync::anonymous_namespace{MixdownUploader.cpp}::CalculateChannels(), audacity::cloud::audiocom::sync::Empty, audacity::cloud::audiocom::sync::Failed, audacity::cloud::audiocom::sync::anonymous_namespace{MixdownUploader.cpp}::GenerateTempPath(), ExportPluginRegistry::Get(), ProjectRate::Get(), TrackList::Get(), audacity::cloud::audiocom::ServiceConfig::GetExportConfig(), anonymous_namespace{TimeTrack.cpp}::GetRate(), audacity::cloud::audiocom::GetServiceConfig(), audacity::cloud::audiocom::sync::anonymous_namespace{MixdownUploader.cpp}::HasPlayableTracks(), mDataExporter, mExportedFilePath, mFinished, mProject, mPromise, ExportTaskBuilder::SetFileName(), ExportTaskBuilder::SetNumChannels(), ExportTaskBuilder::SetParameters(), ExportTaskBuilder::SetPlugin(), ExportTaskBuilder::SetRange(), ExportTaskBuilder::SetSampleRate(), audacity::ToWXString(), and tracks.

Referenced by MixdownUploader().

Here is the call graph for this function:

Here is the caller graph for this function:

GetResultFuture()

std::future< MixdownResult > audacity::cloud::audiocom::sync::MixdownUploader::GetResultFuture

(

)

Definition at line 281 of file MixdownUploader.cpp.

{
   return mPromise.get_future();
}

References mPromise.

ReportProgress()

void audacity::cloud::audiocom::sync::MixdownUploader::ReportProgress ( MixdownState  state, double  progress, ResponseResult  uploadResult  )

private

Definition at line 286 of file MixdownUploader.cpp.

{
   mProgress.store(progress);
 
   if (BasicUI::IsUiThread())
   {
      mProgressUpdateQueued = false;
      mProgressCallback(progress);
   }
   else if (!mProgressUpdateQueued)
   {
      mProgressUpdateQueued = true;
 
      BasicUI::CallAfter(
         [weakThis = weak_from_this(), this]
         {
            auto lock = weakThis.lock();
 
            if (!lock)
               return;
 
            if (mFinished.load())
               return;
 
            mProgressCallback(mProgress.load());
 
            mProgressUpdateQueued = false;
         });
   }
 
   if (
      state == MixdownState::Succeeded || state == MixdownState::Failed ||
      state == MixdownState::Cancelled)
   {
      mFinished.store(true);
      mPromise.set_value({ state, uploadResult });
   }
}

References BasicUI::CallAfter(), audacity::cloud::audiocom::sync::Cancelled, audacity::cloud::audiocom::sync::Failed, BasicUI::IsUiThread(), mFinished, mProgress, mProgressCallback, mProgressUpdateQueued, mPromise, and audacity::cloud::audiocom::sync::Succeeded.

Referenced by UploadMixdown().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUrls()

void audacity::cloud::audiocom::sync::MixdownUploader::SetUrls

(

const UploadUrls &

urls

)

Definition at line 257 of file MixdownUploader.cpp.

{
   auto lock = std::lock_guard { mUploadUrlsMutex };
 
   assert(!mUploadUrls);
   mUploadUrls = urls;
 
   mUploadUrlsSet.notify_one();
}

References mUploadUrls, mUploadUrlsMutex, and mUploadUrlsSet.

Upload()

std::shared_ptr< MixdownUploader > audacity::cloud::audiocom::sync::MixdownUploader::Upload ( concurrency::CancellationContextPtr  cancellationContext, const ServiceConfig &  config, const AudacityProject &  project, MixdownProgressCallback  progressCallback  )

static

Definition at line 238 of file MixdownUploader.cpp.

{
   if (!progressCallback)
      progressCallback = [](auto...) { return true; };
 
   if (!cancellationContext)
      cancellationContext =
         concurrency::CancellationContext::Create();
 
   auto uploader = std::make_shared<MixdownUploader>(
      Tag {}, cancellationContext, config, project, std::move(progressCallback));
 
   cancellationContext->OnCancelled(uploader);
 
   return uploader;
}

References audacity::concurrency::CancellationContext::Create(), and project.

Referenced by audacity::cloud::audiocom::sync::UploadMixdown().

Here is the call graph for this function:

Here is the caller graph for this function:

UploadMixdown()

void audacity::cloud::audiocom::sync::MixdownUploader::UploadMixdown ( )

private

Definition at line 401 of file MixdownUploader.cpp.

{
   ReportProgress(MixdownState::WaitingForUrls, 0.0, {});
 
   {
      auto lock = std::unique_lock { mUploadUrlsMutex };
      mUploadUrlsSet.wait(
         lock, [this] { return mUploadCancelled.load() || !!mUploadUrls; });
   }
 
   if (mUploadCancelled.load(std::memory_order_acquire))
   {
      ReportProgress(MixdownState::Cancelled, 0.0, {});
      return;
   }
 
   ReportProgress(MixdownState::Uploading, 0.0, {});
 
   DataUploader::Get().Upload(
      mCancellationContext, mServiceConfig, *mUploadUrls, mExportedFilePath,
      [this, strongThis = shared_from_this()](ResponseResult result)
      {
         const auto state = [code = result.Code]
         {
            if (code == SyncResultCode::Success)
               return MixdownState::Succeeded;
            else if (code == SyncResultCode::Cancelled)
               return MixdownState::Cancelled;
            else
               return MixdownState::Failed;
         }();
 
         ReportProgress(state, 1.0, result);
      },
      [this, strongThis = shared_from_this()](double progress)
      { ReportProgress(MixdownState::Uploading, progress, {}); });
}

References audacity::cloud::audiocom::Cancelled, audacity::cloud::audiocom::sync::Cancelled, audacity::cloud::audiocom::ResponseResult::Code, audacity::cloud::audiocom::sync::Failed, audacity::cloud::audiocom::sync::DataUploader::Get(), mCancellationContext, mExportedFilePath, mServiceConfig, mUploadCancelled, mUploadUrls, mUploadUrlsMutex, mUploadUrlsSet, ReportProgress(), audacity::cloud::audiocom::sync::Succeeded, audacity::cloud::audiocom::Success, audacity::cloud::audiocom::sync::DataUploader::Upload(), audacity::cloud::audiocom::sync::Uploading, and audacity::cloud::audiocom::sync::WaitingForUrls.

Here is the call graph for this function:

Member Data Documentation

mCancellationContext

concurrency::CancellationContextPtr audacity::cloud::audiocom::sync::MixdownUploader::mCancellationContext

private

Definition at line 115 of file MixdownUploader.h.

Referenced by UploadMixdown().

mDataExporter

std::unique_ptr<DataExporter> audacity::cloud::audiocom::sync::MixdownUploader::mDataExporter

private

Definition at line 102 of file MixdownUploader.h.

Referenced by Cancel(), and ExportProject().

mExportedFilePath

std::string audacity::cloud::audiocom::sync::MixdownUploader::mExportedFilePath

private

Definition at line 104 of file MixdownUploader.h.

Referenced by ExportProject(), UploadMixdown(), and ~MixdownUploader().

mFinished

std::atomic<bool> audacity::cloud::audiocom::sync::MixdownUploader::mFinished { false }

private

Definition at line 111 of file MixdownUploader.h.

Referenced by ExportProject(), and ReportProgress().

mProgress

std::atomic<double> audacity::cloud::audiocom::sync::MixdownUploader::mProgress {}

private

Definition at line 106 of file MixdownUploader.h.

Referenced by ReportProgress().

mProgressCallback

MixdownProgressCallback audacity::cloud::audiocom::sync::MixdownUploader::mProgressCallback

private

Definition at line 99 of file MixdownUploader.h.

Referenced by ReportProgress().

mProgressUpdateQueued

bool audacity::cloud::audiocom::sync::MixdownUploader::mProgressUpdateQueued { false }

private

Definition at line 108 of file MixdownUploader.h.

Referenced by ReportProgress().

mProject

const AudacityProject& audacity::cloud::audiocom::sync::MixdownUploader::mProject

private

Definition at line 93 of file MixdownUploader.h.

Referenced by ExportProject().

mPromise

std::promise<MixdownResult> audacity::cloud::audiocom::sync::MixdownUploader::mPromise

private

Definition at line 113 of file MixdownUploader.h.

Referenced by ExportProject(), GetResultFuture(), and ReportProgress().

mServiceConfig

const ServiceConfig& audacity::cloud::audiocom::sync::MixdownUploader::mServiceConfig

private

Definition at line 92 of file MixdownUploader.h.

Referenced by UploadMixdown().

mUploadCancelled

std::atomic<bool> audacity::cloud::audiocom::sync::MixdownUploader::mUploadCancelled { false }

private

Definition at line 110 of file MixdownUploader.h.

Referenced by Cancel(), and UploadMixdown().

mUploadUrls

std::optional<UploadUrls> audacity::cloud::audiocom::sync::MixdownUploader::mUploadUrls

private

Definition at line 97 of file MixdownUploader.h.

Referenced by SetUrls(), and UploadMixdown().

mUploadUrlsMutex

std::mutex audacity::cloud::audiocom::sync::MixdownUploader::mUploadUrlsMutex

private

Definition at line 95 of file MixdownUploader.h.

Referenced by SetUrls(), and UploadMixdown().

mUploadUrlsSet

std::condition_variable audacity::cloud::audiocom::sync::MixdownUploader::mUploadUrlsSet

private

Definition at line 96 of file MixdownUploader.h.

Referenced by Cancel(), SetUrls(), and UploadMixdown().

---

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

• MixdownUploader.h
• MixdownUploader.cpp