Inheritance diagram for ExportWavPack:

Collaboration diagram for ExportWavPack:

Public Member Functions
	ExportWavPack ()

void	OptionsCreate (ShuttleGui &S, int format) override

ProgressResult	Export (AudacityProject project, std::unique_ptr< BasicUI::ProgressDialog > &pDialog, unsigned channels, const wxFileNameWrapper &fName, bool selectedOnly, double t0, double t1, MixerSpec mixerSpec=NULL, const Tags *metadata=NULL, int subformat=0) override
	called to export audio into a file. More...

Public Member Functions inherited from ExportPlugin
	ExportPlugin ()

virtual	~ExportPlugin ()

int	AddFormat ()
	Add a NEW entry to the list of formats this plug-in can export. More...

void	SetFormat (const wxString &format, int index)

void	SetDescription (const TranslatableString &description, int index)

void	AddExtension (const FileExtension &extension, int index)

void	SetExtensions (FileExtensions extensions, int index)

void	SetMask (FileNames::FileTypes mask, int index)

void	SetMaxChannels (unsigned maxchannels, unsigned index)

void	SetCanMetaData (bool canmetadata, int index)

virtual int	GetFormatCount ()

virtual wxString	GetFormat (int index)

TranslatableString	GetDescription (int index)

virtual FileExtension	GetExtension (int index=0)
	Return the (first) file name extension for the sub-format. More...

virtual FileExtensions	GetExtensions (int index=0)
	Return all the file name extensions used for the sub-format. More...

FileNames::FileTypes	GetMask (int index)

virtual unsigned	GetMaxChannels (int index)

virtual bool	GetCanMetaData (int index)

virtual bool	IsExtension (const FileExtension &ext, int index)

virtual bool	DisplayOptions (wxWindow *parent, int format=0)

virtual void	OptionsCreate (ShuttleGui &S, int format)=0

virtual bool	CheckFileName (wxFileName &filename, int format=0)

virtual int	SetNumExportChannels ()
	Exporter plug-ins may override this to specify the number of channels in exported file. -1 for unspecified. More...

virtual ProgressResult	Export (AudacityProject project, std::unique_ptr< BasicUI::ProgressDialog > &pDialog, unsigned channels, const wxFileNameWrapper &fName, bool selectedOnly, double t0, double t1, MixerSpec mixerSpec=NULL, const Tags *metadata=NULL, int subformat=0)=0
	called to export audio into a file. More...

Static Public Member Functions
static int	WriteBlock (void id, void data, int32_t length)

Additional Inherited Members
Public Types inherited from ExportPlugin
using	ProgressResult = BasicUI::ProgressResult

Protected Member Functions inherited from ExportPlugin
std::unique_ptr< Mixer >	CreateMixer (const TrackList &tracks, bool selectionOnly, double startTime, double stopTime, unsigned numOutChannels, size_t outBufferSize, bool outInterleaved, double outRate, sampleFormat outFormat, MixerSpec *mixerSpec)

Static Protected Member Functions inherited from ExportPlugin
static void	InitProgress (std::unique_ptr< BasicUI::ProgressDialog > &pDialog, const TranslatableString &title, const TranslatableString &message)

static void	InitProgress (std::unique_ptr< BasicUI::ProgressDialog > &pDialog, const wxFileNameWrapper &title, const TranslatableString &message)

Detailed Description

Definition at line 240 of file ExportWavPack.cpp.

Constructor & Destructor Documentation

◆ ExportWavPack()

ExportWavPack::ExportWavPack ( )

Definition at line 262 of file ExportWavPack.cpp.

:  ExportPlugin()
{
   AddFormat();
   SetFormat(wxT("WavPack"),0);
   AddExtension(wxT("wv"),0);
   SetMaxChannels(255,0);
   SetCanMetaData(true,0);
   SetDescription(XO("WavPack Files"),0);
}

References ExportPlugin::AddExtension(), ExportPlugin::AddFormat(), ExportPlugin::SetCanMetaData(), ExportPlugin::SetDescription(), ExportPlugin::SetFormat(), ExportPlugin::SetMaxChannels(), wxT(), and XO().

Here is the call graph for this function:

Member Function Documentation

◆ Export()

ProgressResult ExportWavPack::Export	(	AudacityProject *	project,
		std::unique_ptr< BasicUI::ProgressDialog > &	pDialog,
		unsigned	channels,
		const wxFileNameWrapper &	fName,
		bool	selectedOnly,
		double	t0,
		double	t1,
		MixerSpec *	mixerSpec = `NULL`,
		const Tags *	metadata = `NULL`,
		int	subformat = `0`
	)

overridevirtual

called to export audio into a file.

Parameters

pDialog	To be initialized with pointer to a NEW ProgressDialog if it was null, otherwise gives an existing dialog to be reused (working around a problem in wxWidgets for Mac; see bug 1600)
selectedOnly	Set to true if all tracks should be mixed, to false if only the selected tracks should be mixed and exported.
metadata	A Tags object that will over-ride the one in *project and be used to tag the file that is exported.
subformat	Control which of the multiple formats this exporter is capable of exporting should be used. Used where a single export plug-in handles a number of related formats, but they have separate entries in the Format drop-down list box. For example, the options to export to "Other PCM", "AIFF 16 Bit" and "WAV 16 Bit" are all the same libsndfile export plug-in, but with subformat set to 0, 1, and 2 respectively.

Returns: ProgressResult::Failed or ProgressResult::Cancelled if export fails to complete for any reason, in which case this function is responsible for alerting the user. Otherwise ProgressResult::Success or ProgressResult::Stopped

Implements ExportPlugin.

Definition at line 273 of file ExportWavPack.cpp.

{
   WavpackConfig config = {};
   WriteId outWvFile, outWvcFile;
   outWvFile.file = std::make_unique< wxFile >();
 
   if (!outWvFile.file->Create(fName.GetFullPath(), true) || !outWvFile.file.get()->IsOpened()) {
      AudacityMessageBox( XO("Unable to open target file for writing") );
      return ProgressResult::Failed;
   }
   
   double rate = ProjectRate::Get( *project ).GetRate();
   const auto &tracks = TrackList::Get( *project );
 
   int quality = QualitySetting.Read();
   bool hybridMode = HybridModeSetting.Read();
   bool createCorrectionFile = CreateCorrectionFileSetting.Read();
   int bitRate = BitrateSetting.Read();
   int bitDepth = BitDepthSetting.Read();
 
   sampleFormat format = int16Sample;
   if (bitDepth == 24) {
      format = int24Sample;
   } else if (bitDepth == 32) {
      format = floatSample;
   }
 
   config.num_channels = numChannels;
   config.sample_rate = rate;
   config.bits_per_sample = bitDepth;
   config.bytes_per_sample = bitDepth/8;
   config.float_norm_exp = format == floatSample ? 127 : 0;
 
   if (config.num_channels <= 2)
      config.channel_mask = 0x5 - config.num_channels;
   else if (config.num_channels <= 18)
      config.channel_mask = (1U << config.num_channels) - 1;
   else
      config.channel_mask = 0x3FFFF;
 
   if (quality == 0) {
      config.flags |= CONFIG_FAST_FLAG;
   } else if (quality == 2) {
      config.flags |= CONFIG_HIGH_FLAG;
   } else if (quality == 3) {
      config.flags |= CONFIG_HIGH_FLAG | CONFIG_VERY_HIGH_FLAG;
   }
 
   if (hybridMode) {
      config.flags |= CONFIG_HYBRID_FLAG;
      config.bitrate = bitRate / 10.0;
 
      if (createCorrectionFile) {
         config.flags |= CONFIG_CREATE_WVC;
 
         outWvcFile.file = std::make_unique< wxFile >();
         if (!outWvcFile.file->Create(fName.GetFullPath().Append("c"), true)) {
            AudacityMessageBox( XO("Unable to create target file for writing") );
            return ProgressResult::Failed;
         }
      }
   }
 
   // If we're not creating a correction file now, any one that currently exists with this name
   // will become obsolete now, so delete it if it happens to exist (although it usually won't)
 
   if (!hybridMode || !createCorrectionFile)
      wxRemoveFile(fName.GetFullPath().Append("c"));
 
   WavpackContext *wpc = WavpackOpenFileOutput(WriteBlock, &outWvFile, createCorrectionFile ? &outWvcFile : nullptr);
   auto closeWavPackContext = finally([wpc]() { WavpackCloseFile(wpc); });
 
   if (!WavpackSetConfiguration64(wpc, &config, -1, nullptr) || !WavpackPackInit(wpc)) {
      ShowExportErrorDialog( WavpackGetErrorMessage(wpc) );
      return ProgressResult::Failed;
   }
 
   // Samples to write per run
   constexpr size_t SAMPLES_PER_RUN = 8192u;
 
   const size_t bufferSize = SAMPLES_PER_RUN * numChannels;
   ArrayOf<int32_t> wavpackBuffer{ bufferSize };
   auto updateResult = ProgressResult::Success;
   {
      auto mixer = CreateMixer(tracks, selectionOnly,
         t0, t1,
         numChannels, SAMPLES_PER_RUN, true,
         rate, format, mixerSpec);
 
      InitProgress( pDialog, fName,
         selectionOnly
            ? XO("Exporting selected audio as WavPack")
            : XO("Exporting the audio as WavPack") );
      auto &progress = *pDialog;
 
      while (updateResult == ProgressResult::Success) {
         auto samplesThisRun = mixer->Process();
 
         if (samplesThisRun == 0)
            break;
         
         if (format == int16Sample) {
            const int16_t *mixed = reinterpret_cast<const int16_t*>(mixer->GetBuffer());
            for (decltype(samplesThisRun) j = 0; j < samplesThisRun; j++) {
               for (size_t i = 0; i < numChannels; i++) {
                  wavpackBuffer[j*numChannels + i] = (static_cast<int32_t>(*mixed++) * 65536) >> 16;
               }
            }
         } else {
            const int *mixed = reinterpret_cast<const int*>(mixer->GetBuffer());
            for (decltype(samplesThisRun) j = 0; j < samplesThisRun; j++) {
               for (size_t i = 0; i < numChannels; i++) {
                  wavpackBuffer[j*numChannels + i] = *mixed++;
               }
            }
         }
 
         if (!WavpackPackSamples(wpc, wavpackBuffer.get(), samplesThisRun)) {
            ShowExportErrorDialog( WavpackGetErrorMessage(wpc) );
            return ProgressResult::Failed;
         }
 
         if (updateResult == ProgressResult::Success)
            updateResult =
               progress.Poll(mixer->MixGetCurrentTime() - t0, t1 - t0);
      }
   }
 
   if (!WavpackFlushSamples(wpc)) {
      ShowExportErrorDialog( WavpackGetErrorMessage(wpc) );
      return ProgressResult::Failed;
   } else {
      if (metadata == NULL)
         metadata = &Tags::Get( *project );
 
      wxString n;
      for (const auto &pair : metadata->GetRange()) {
         n = pair.first;
         const auto &v = pair.second;
 
         WavpackAppendTagItem(wpc,
                              n.mb_str(wxConvUTF8),
                              v.mb_str(wxConvUTF8),
                              static_cast<int>( strlen(v.mb_str(wxConvUTF8)) ));
      }
 
      if (!WavpackWriteTag(wpc)) {
         ShowExportErrorDialog( WavpackGetErrorMessage(wpc) );
         return ProgressResult::Failed;
      }
   }
 
   if ( !outWvFile.file.get()->Close()
      || ( outWvcFile.file && outWvcFile.file.get() && !outWvcFile.file.get()->Close())) {
      return ProgressResult::Failed;
   }
 
   // wxFile::Create opens the file with only write access
   // So, need to open the file again with both read and write access
   if (!outWvFile.file->Open(fName.GetFullPath(), wxFile::read_write)) {
      ShowExportErrorDialog( "Unable to update the actual length of the file" );
      return ProgressResult::Failed;
   }
 
   ArrayOf<int32_t> firstBlockBuffer { outWvFile.firstBlockSize };
   size_t bytesRead = outWvFile.file->Read(firstBlockBuffer.get(), outWvFile.firstBlockSize);
 
   // Update the first block written with the actual number of samples written
   WavpackUpdateNumSamples(wpc, firstBlockBuffer.get());
   outWvFile.file->Seek(0);
   size_t bytesWritten = outWvFile.file->Write(firstBlockBuffer.get(), outWvFile.firstBlockSize);
 
   if ( !outWvFile.file.get()->Close() ) {
      return ProgressResult::Failed;
   }
 
   return updateResult;
}

References AudacityMessageBox(), anonymous_namespace{ExportWavPack.cpp}::BitDepthSetting, anonymous_namespace{ExportWavPack.cpp}::BitrateSetting, anonymous_namespace{ExportWavPack.cpp}::CreateCorrectionFileSetting, ExportPlugin::CreateMixer(), WriteId::file, WriteId::firstBlockSize, floatSample, format, ProjectRate::Get(), Tags::Get(), TrackList::Get(), Tags::GetRange(), ProjectRate::GetRate(), anonymous_namespace{ExportWavPack.cpp}::HybridModeSetting, ExportPlugin::InitProgress(), int16Sample, int24Sample, anonymous_namespace{ExportWavPack.cpp}::QualitySetting, Setting< T >::Read(), SAMPLES_PER_RUN, ShowExportErrorDialog(), BasicUI::Success, WriteBlock(), and XO().

Here is the call graph for this function:

◆ OptionsCreate()

void ExportWavPack::OptionsCreate	(	ShuttleGui &	S,
		int	format
	)

overridevirtual

Implements ExportPlugin.

Definition at line 489 of file ExportWavPack.cpp.

{
   S.AddWindow( safenew ExportWavPackOptions{ S.GetParent(), format } );
}

References format, S, and safenew.

◆ WriteBlock()

int ExportWavPack::WriteBlock	(	void *	id,
		void *	data,
		int32_t	length
	)

static

Definition at line 463 of file ExportWavPack.cpp.

{
    if (id == nullptr || data == nullptr || length == 0)
        return true; // This is considered to be success in wavpack.c reference code
 
    WriteId *outId = static_cast<WriteId*>(id);
 
    if (!outId->file)
        // This does not match the wavpack.c but in our case if file is nullptr - 
        // the stream error has occured
        return false; 
 
   //  if (!outId->file->Write(data, length).IsOk()) {
    if (outId->file->Write(data, length) != length) {
        outId->file.reset();
        return false;
    }
 
    outId->bytesWritten += length;
 
    if (outId->firstBlockSize == 0)
        outId->firstBlockSize = length;
 
    return true;
}

References WriteId::bytesWritten, WriteId::file, WriteId::firstBlockSize, and id.

Referenced by Export().

Here is the caller graph for this function:

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

ExportWavPack.cpp

Public Member Functions

Static Public Member Functions