WavPackExportProcessor Class Reference

Inheritance diagram for WavPackExportProcessor:

Collaboration diagram for WavPackExportProcessor:

Public Member Functions
	~WavPackExportProcessor ()
bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double sampleRate, unsigned channels, MixerOptions::Downmix *mixerSpec, const Tags *tags) override
	Called before start processing. More...
ExportResult	Process (ExportProcessorDelegate &delegate) override
Public Member Functions inherited from ExportProcessor
	ExportProcessor (const ExportProcessor &)=delete
ExportProcessor &	operator= (const ExportProcessor &)=delete
	ExportProcessor ()=default
virtual	~ExportProcessor ()
virtual bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double rate, unsigned channels, MixerOptions::Downmix *mixerSpec=nullptr, const Tags *tags=nullptr)=0
	Called before start processing. More...
virtual ExportResult	Process (ExportProcessorDelegate &delegate)=0

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

Private Attributes
struct {
TranslatableString   status
double   t0
double   t1
unsigned   numChannels
wxFileNameWrapper   fName
sampleFormat   format
WriteId   outWvFile
WriteId   outWvcFile
WavpackContext *   wpc {}
std::unique_ptr< Mixer >   mixer
std::unique_ptr< Tags >   metadata
}	context

Static Private Attributes
static constexpr size_t	SAMPLES_PER_RUN = 8192u

Additional Inherited Members
Public Types inherited from ExportProcessor
using	Parameters = std::vector< std::tuple< ExportOptionID, ExportValue > >

Detailed Description

Definition at line 244 of file ExportWavPack.cpp.

Constructor & Destructor Documentation

~WavPackExportProcessor()

WavPackExportProcessor::~WavPackExportProcessor

(

)

Definition at line 373 of file ExportWavPack.cpp.

{
   if(context.wpc)
      WavpackCloseFile(context.wpc);
}

References context.

Member Function Documentation

Initialize()

bool WavPackExportProcessor::Initialize ( AudacityProject &  project, const Parameters &  parameters, const wxFileNameWrapper &  filename, double  t0, double  t1, bool  selectedOnly, double  rate, unsigned  channels, MixerOptions::Downmix *  mixerSpec, const Tags *  tags  )

overridevirtual

Called before start processing.

Parameters

project	Processor may access project data, take care to exclude any data race
parameters	A format-dependent set of parameters used in exporting
selectedOnly	Set to true if all tracks should be mixed, to false if only the selected tracks should be mixed and exported.
tags	A Tags object that will over-ride the one in *project and be used to tag the file that is exported. @retern Implementations may simply return false without any error reporting. This is to temporarily preserve old behavior, which is to be removed in the nearest future.

Implements ExportProcessor.

Definition at line 379 of file ExportWavPack.cpp.

{
   context.t0 = t0;
   context.t1 = t1;
   context.numChannels = numChannels;
   context.fName = fName;
 
   WavpackConfig config = {};
   auto& outWvFile = context.outWvFile;
   auto& outWvcFile = context.outWvcFile;
   outWvFile.file = std::make_unique< wxFile >();
 
   if (!outWvFile.file->Create(fName.GetFullPath(), true) || !outWvFile.file->IsOpened()) {
      throw ExportException(_("Unable to open target file for writing"));
   }
   
   const auto &tracks = TrackList::Get( project );
 
   const auto quality = ExportPluginHelpers::GetParameterValue<int>(
      parameters,
      OptionIDQuality,
      1);
   const auto hybridMode = ExportPluginHelpers::GetParameterValue<bool>(
      parameters,
      OptionIDHybridMode,
      false);
   const auto createCorrectionFile = ExportPluginHelpers::GetParameterValue<bool>(
      parameters,
      OptionIDCreateCorrection,
      false);
   const auto bitRate = ExportPluginHelpers::GetParameterValue<int>(
      parameters,
      OptionIDBitRate,
      40);
   const auto bitDepth = ExportPluginHelpers::GetParameterValue<int>(
      parameters,
      OptionIDBitDepth,
      16);
 
 
   context.format = int16Sample;
   if (bitDepth == 24) {
      context.format = int24Sample;
   } else if (bitDepth == 32) {
      context.format = floatSample;
   }
 
   config.num_channels = numChannels;
   config.sample_rate = sampleRate;
   config.bits_per_sample = bitDepth;
   config.bytes_per_sample = bitDepth/8;
   config.float_norm_exp = context.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)) {
            throw ExportException(_("Unable to create target file for writing"));
         }
      }
   }
 
   // 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"));
 
   context.wpc = WavpackOpenFileOutput(WriteBlock, &outWvFile, createCorrectionFile ? &outWvcFile : nullptr);
   if (!WavpackSetConfiguration64(context.wpc, &config, -1, nullptr) || !WavpackPackInit(context.wpc)) {
      throw ExportErrorException( WavpackGetErrorMessage(context.wpc) );
   }
   
   context.status = selectionOnly
      ? XO("Exporting selected audio as WavPack")
      : XO("Exporting the audio as WavPack");
   
   context.metadata = std::make_unique<Tags>(
      metadata == nullptr
         ? Tags::Get( project )
         : *metadata
      );
 
   context.mixer = ExportPluginHelpers::CreateMixer(tracks, selectionOnly,
         t0, t1,
         numChannels, SAMPLES_PER_RUN, true,
         sampleRate, context.format, mixerSpec);
 
   return true;
}

References _, context, ExportPluginHelpers::CreateMixer(), WriteId::file, floatSample, fName, Tags::Get(), TrackList::Get(), int16Sample, int24Sample, metadata, numChannels, anonymous_namespace{ExportWavPack.cpp}::OptionIDBitDepth, anonymous_namespace{ExportWavPack.cpp}::OptionIDBitRate, anonymous_namespace{ExportWavPack.cpp}::OptionIDCreateCorrection, anonymous_namespace{ExportWavPack.cpp}::OptionIDHybridMode, anonymous_namespace{ExportWavPack.cpp}::OptionIDQuality, outWvcFile, outWvFile, project, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, SAMPLES_PER_RUN, t0, t1, tracks, WriteBlock(), and XO().

Here is the call graph for this function:

Process()

ExportResult WavPackExportProcessor::Process ( ExportProcessorDelegate &  delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 496 of file ExportWavPack.cpp.

{
   delegate.SetStatusString(context.status);
 
   const size_t bufferSize = SAMPLES_PER_RUN * context.numChannels;
 
   ArrayOf<int32_t> wavpackBuffer{ bufferSize };
 
   auto exportResult = ExportResult::Success;
   {
 
      while (exportResult == ExportResult::Success) {
         auto samplesThisRun = context.mixer->Process();
 
         if (samplesThisRun == 0)
            break;
         
         if (context.format == int16Sample) {
            const int16_t *mixed = reinterpret_cast<const int16_t*>(context.mixer->GetBuffer());
            for (decltype(samplesThisRun) j = 0; j < samplesThisRun; j++) {
               for (size_t i = 0; i < context.numChannels; i++) {
                  wavpackBuffer[j*context.numChannels + i] = (static_cast<int32_t>(*mixed++) * 65536) >> 16;
               }
            }
         } else {
            const int *mixed = reinterpret_cast<const int*>(context.mixer->GetBuffer());
            for (decltype(samplesThisRun) j = 0; j < samplesThisRun; j++) {
               for (size_t i = 0; i < context.numChannels; i++) {
                  wavpackBuffer[j*context.numChannels + i] = *mixed++;
               }
            }
         }
 
         if (!WavpackPackSamples(context.wpc, wavpackBuffer.get(), samplesThisRun)) {
            throw ExportErrorException(WavpackGetErrorMessage(context.wpc));
         }
         exportResult = ExportPluginHelpers::UpdateProgress(
            delegate, *context.mixer, context.t0, context.t1);
      }
   }
 
   if (!WavpackFlushSamples(context.wpc)) {
      throw ExportErrorException( WavpackGetErrorMessage(context.wpc) );
   } else {
      
 
      wxString n;
      for (const auto &pair : context.metadata->GetRange()) {
         n = pair.first;
         const auto &v = pair.second;
 
         WavpackAppendTagItem(context.wpc,
                              n.mb_str(wxConvUTF8),
                              v.mb_str(wxConvUTF8),
                              static_cast<int>( strlen(v.mb_str(wxConvUTF8)) ));
      }
 
      if (!WavpackWriteTag(context.wpc)) {
         throw ExportErrorException( WavpackGetErrorMessage(context.wpc) );
      }
   }
 
   if ( !context.outWvFile.file.get()->Close()
      || ( context.outWvcFile.file && context.outWvcFile.file.get() && !context.outWvcFile.file.get()->Close())) {
      return ExportResult::Error;
   }
 
   // wxFile::Create opens the file with only write access
   // So, need to open the file again with both read and write access
   if (!context.outWvFile.file->Open(context.fName.GetFullPath(), wxFile::read_write)) {
      throw ExportErrorException("Unable to update the actual length of the file");
   }
 
   ArrayOf<int32_t> firstBlockBuffer { context.outWvFile.firstBlockSize };
   context.outWvFile.file->Read(firstBlockBuffer.get(), context.outWvFile.firstBlockSize);
 
   // Update the first block written with the actual number of samples written
   WavpackUpdateNumSamples(context.wpc, firstBlockBuffer.get());
   context.outWvFile.file->Seek(0);
   context.outWvFile.file->Write(firstBlockBuffer.get(), context.outWvFile.firstBlockSize);
 
   if ( !context.outWvFile.file.get()->Close() ) {
      return ExportResult::Error;
   }
   return exportResult;
}

References context, Error, int16Sample, SAMPLES_PER_RUN, ExportProcessorDelegate::SetStatusString(), Success, and ExportPluginHelpers::UpdateProgress().

Here is the call graph for this function:

WriteBlock()

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

staticprivate

Definition at line 586 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 Initialize().

Here is the caller graph for this function:

Member Data Documentation

struct { ... } WavPackExportProcessor::context

Referenced by Initialize(), Process(), and ~WavPackExportProcessor().

fName

wxFileNameWrapper WavPackExportProcessor::fName

Definition at line 255 of file ExportWavPack.cpp.

Referenced by Initialize().

format

sampleFormat WavPackExportProcessor::format

Definition at line 256 of file ExportWavPack.cpp.

metadata

std::unique_ptr<Tags> WavPackExportProcessor::metadata

Definition at line 260 of file ExportWavPack.cpp.

Referenced by Initialize().

mixer

std::unique_ptr<Mixer> WavPackExportProcessor::mixer

Definition at line 259 of file ExportWavPack.cpp.

numChannels

unsigned WavPackExportProcessor::numChannels

Definition at line 254 of file ExportWavPack.cpp.

Referenced by Initialize().

outWvcFile

WriteId WavPackExportProcessor::outWvcFile

Definition at line 257 of file ExportWavPack.cpp.

Referenced by Initialize().

outWvFile

WriteId WavPackExportProcessor::outWvFile

Definition at line 257 of file ExportWavPack.cpp.

Referenced by Initialize().

SAMPLES_PER_RUN

constexpr size_t WavPackExportProcessor::SAMPLES_PER_RUN = 8192u

staticconstexprprivate

Definition at line 247 of file ExportWavPack.cpp.

Referenced by Initialize(), and Process().

status

TranslatableString WavPackExportProcessor::status

Definition at line 251 of file ExportWavPack.cpp.

t0

double WavPackExportProcessor::t0

Definition at line 252 of file ExportWavPack.cpp.

Referenced by Initialize().

t1

double WavPackExportProcessor::t1

Definition at line 253 of file ExportWavPack.cpp.

Referenced by Initialize().

wpc

WavpackContext* WavPackExportProcessor::wpc {}

Definition at line 258 of file ExportWavPack.cpp.

---

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

• ExportWavPack.cpp