FLACExportProcessor Class Reference

Inheritance diagram for FLACExportProcessor:

Collaboration diagram for FLACExportProcessor:

Public Member Functions
bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double sampleFormat, 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

Private Member Functions
FLAC__StreamMetadataHandle	MakeMetadata (AudacityProject *project, const Tags *tags) const

Private Attributes
struct {
TranslatableString   status
double   t0
double   t1
unsigned   numChannels
wxFileNameWrapper   fName
sampleFormat   format
FLAC::Encoder::File   encoder
wxFFile   f
std::unique_ptr< Mixer >   mixer
}	context

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

Detailed Description

Definition at line 175 of file ExportFLAC.cpp.

Member Function Documentation

Initialize()

bool FLACExportProcessor::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 293 of file ExportFLAC.cpp.

{
   context.t0 = t0;
   context.t1 = t1;
   context.numChannels = numChannels;
   context.fName = fName;
 
   wxLogNull logNo;            // temporarily disable wxWidgets error messages
 
   long levelPref = std::stol(ExportPluginHelpers::GetParameterValue<std::string>(parameters, FlacOptionIDLevel));
   auto bitDepthPref = ExportPluginHelpers::GetParameterValue<std::string>(parameters, FlacOptionIDBitDepth);
 
 
   auto& encoder = context.encoder;
 
   bool success = true;
   success = success &&
#ifdef LEGACY_FLAC
   encoder.set_filename(OSOUTPUT(fName)) &&
#endif
   encoder.set_channels(numChannels) &&
   encoder.set_sample_rate(lrint(sampleRate));
 
   // See note in MakeMetadata() about a bug in libflac++ 1.1.2
   FLAC__StreamMetadataHandle metadata;
   if (success)
      metadata = MakeMetadata(&project, tags);
 
   if (success && !metadata) {
      // TODO: more precise message
      throw ExportErrorException("FLAC:283");
   }
 
   if (success && metadata) {
      // set_metadata expects an array of pointers to metadata and a size.
      // The size is 1.
      FLAC__StreamMetadata *p = metadata.get();
      success = encoder.set_metadata(&p, 1);
   }
 
 
   if (bitDepthPref == "24") {
      context.format = int24Sample;
      success = success && encoder.set_bits_per_sample(24);
   } else { //convert float to 16 bits
      context.format = int16Sample;
      success = success && encoder.set_bits_per_sample(16);
   }
 
 
   // Duplicate the flac command line compression levels
   if (levelPref < 0 || levelPref > 8) {
      levelPref = 5;
   }
   success = success &&
   encoder.set_do_exhaustive_model_search(flacLevels[levelPref].do_exhaustive_model_search) &&
   encoder.set_do_escape_coding(flacLevels[levelPref].do_escape_coding);
 
   if (numChannels != 2) {
      success = success &&
      encoder.set_do_mid_side_stereo(false) &&
      encoder.set_loose_mid_side_stereo(false);
   }
   else {
      success = success &&
      encoder.set_do_mid_side_stereo(flacLevels[levelPref].do_mid_side_stereo) &&
      encoder.set_loose_mid_side_stereo(flacLevels[levelPref].loose_mid_side_stereo);
   }
 
   success = success &&
   encoder.set_qlp_coeff_precision(flacLevels[levelPref].qlp_coeff_precision) &&
   encoder.set_min_residual_partition_order(flacLevels[levelPref].min_residual_partition_order) &&
   encoder.set_max_residual_partition_order(flacLevels[levelPref].max_residual_partition_order) &&
   encoder.set_rice_parameter_search_dist(flacLevels[levelPref].rice_parameter_search_dist) &&
   encoder.set_max_lpc_order(flacLevels[levelPref].max_lpc_order);
 
   if (!success) {
      // TODO: more precise message
      throw ExportErrorException("FLAC:336");
   }
 
#ifdef LEGACY_FLAC
   encoder.init();
#else
   const auto path = fName.GetFullPath();
   if (!context.f.Open(path, wxT("w+b"))) {
      throw ExportException(XO("FLAC export couldn't open %s")
         .Format( path )
         .Translation());
   }
 
   // Even though there is an init() method that takes a filename, use the one that
   // takes a file handle because wxWidgets can open a file with a Unicode name and
   // libflac can't (under Windows).
   int status = encoder.init(context.f.fp());
   if (status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
      throw ExportException(XO("FLAC encoder failed to initialize\nStatus: %d")
            .Format( status )
            .Translation());
   }
#endif
 
   metadata.reset();
 
   context.mixer = ExportPluginHelpers::CreateMixer(
      project, selectionOnly, t0, t1, numChannels, SAMPLES_PER_RUN, false,
      sampleRate, context.format, mixerSpec);
 
   context.status = selectionOnly
      ? XO("Exporting the selected audio as FLAC")
      : XO("Exporting the audio as FLAC");
 
   return true;
}

References context, ExportPluginHelpers::CreateMixer(), do_escape_coding, do_exhaustive_model_search, do_mid_side_stereo, encoder, flacLevels, anonymous_namespace{ExportFLAC.cpp}::FlacOptionIDBitDepth, anonymous_namespace{ExportFLAC.cpp}::FlacOptionIDLevel, fName, int16Sample, int24Sample, loose_mid_side_stereo, lrint, MakeMetadata(), max_lpc_order, max_residual_partition_order, min_residual_partition_order, numChannels, OSOUTPUT, project, qlp_coeff_precision, rice_parameter_search_dist, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, SAMPLES_PER_RUN, status, t0, t1, wxT(), and XO().

Here is the call graph for this function:

MakeMetadata()

FLAC__StreamMetadataHandle FLACExportProcessor::MakeMetadata ( AudacityProject *  project, const Tags *  tags  ) const

private

Definition at line 483 of file ExportFLAC.cpp.

{
   // Retrieve tags if needed
   if (tags == NULL)
      tags = &Tags::Get( *project );
 
   auto metadata = FLAC__StreamMetadataHandle(
      ::FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)
   );
 
   wxString n;
   for (const auto &pair : tags->GetRange()) {
      n = pair.first;
      const auto &v = pair.second;
      if (n == TAG_YEAR) {
         n = wxT("DATE");
      }
      else if (n == TAG_COMMENTS) {
         // Some apps like Foobar use COMMENT and some like Windows use DESCRIPTION,
         // so add both to try and make everyone happy.
         n = wxT("COMMENT");
         FLAC::Metadata::VorbisComment::Entry entry(n.mb_str(wxConvUTF8),
                                                    v.mb_str(wxConvUTF8));
         if (! ::FLAC__metadata_object_vorbiscomment_append_comment(metadata.get(),
                                                              entry.get_entry(),
                                                              true) ) {
            return {};
         }
         n = wxT("DESCRIPTION");
      }
      FLAC::Metadata::VorbisComment::Entry entry(n.mb_str(wxConvUTF8),
                                                 v.mb_str(wxConvUTF8));
      if (! ::FLAC__metadata_object_vorbiscomment_append_comment(metadata.get(),
                                                           entry.get_entry(),
                                                           true) ) {
         return {};
      }
   }
 
   return metadata;
}

References entry, Tags::Get(), Tags::GetRange(), project, TAG_COMMENTS, TAG_YEAR, and wxT().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Process()

ExportResult FLACExportProcessor::Process ( ExportProcessorDelegate &  delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 414 of file ExportFLAC.cpp.

{
   delegate.SetStatusString(context.status);
 
   auto exportResult = ExportResult::Success;
 
   auto cleanup2 = finally( [&] {
      if (exportResult == ExportResult::Cancelled || exportResult == ExportResult::Error) {
#ifndef LEGACY_FLAC
         context.f.Detach(); // libflac closes the file
#endif
         context.encoder.finish();
      }
   } );
 
   ArraysOf<FLAC__int32> tmpsmplbuf{ context.numChannels, SAMPLES_PER_RUN, true };
 
   while (exportResult == ExportResult::Success) {
      auto samplesThisRun = context.mixer->Process();
      if (samplesThisRun == 0) //stop encoding
         break;
 
      for (size_t i = 0; i < context.numChannels; i++) {
         auto mixed = context.mixer->GetBuffer(i);
         if (context.format == int24Sample) {
            for (decltype(samplesThisRun) j = 0; j < samplesThisRun; j++) {
               tmpsmplbuf[i][j] = ((const int *)mixed)[j];
            }
         }
         else {
            for (decltype(samplesThisRun) j = 0; j < samplesThisRun; j++) {
               tmpsmplbuf[i][j] = ((const short *)mixed)[j];
            }
         }
      }
      if (! context.encoder.process(
            reinterpret_cast<FLAC__int32**>( tmpsmplbuf.get() ),
            samplesThisRun) ) {
         // TODO: more precise message
         throw ExportDiskFullError(context.fName);
      }
      exportResult = ExportPluginHelpers::UpdateProgress(
         delegate, *context.mixer, context.t0, context.t1);
   }
 
   if (exportResult != ExportResult::Cancelled && exportResult != ExportResult::Error) {
#ifndef LEGACY_FLAC
      context.f.Detach(); // libflac closes the file
#endif
      if (!context.encoder.finish())
      {
         return ExportResult::Error;
      }
#ifdef LEGACY_FLAC
      if (!context.f.Flush() || !context.f.Close())
      {
         return ExportResult::Error;
      }
#endif
   }
   return exportResult;
}

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

Here is the call graph for this function:

Member Data Documentation

struct { ... } FLACExportProcessor::context

Referenced by Initialize(), and Process().

encoder

FLAC::Encoder::File FLACExportProcessor::encoder

Definition at line 185 of file ExportFLAC.cpp.

Referenced by Initialize().

f

wxFFile FLACExportProcessor::f

Definition at line 186 of file ExportFLAC.cpp.

fName

wxFileNameWrapper FLACExportProcessor::fName

Definition at line 183 of file ExportFLAC.cpp.

Referenced by Initialize().

format

sampleFormat FLACExportProcessor::format

Definition at line 184 of file ExportFLAC.cpp.

mixer

std::unique_ptr<Mixer> FLACExportProcessor::mixer

Definition at line 187 of file ExportFLAC.cpp.

numChannels

unsigned FLACExportProcessor::numChannels

Definition at line 182 of file ExportFLAC.cpp.

Referenced by Initialize().

status

TranslatableString FLACExportProcessor::status

Definition at line 179 of file ExportFLAC.cpp.

Referenced by Initialize().

t0

double FLACExportProcessor::t0

Definition at line 180 of file ExportFLAC.cpp.

Referenced by Initialize().

t1

double FLACExportProcessor::t1

Definition at line 181 of file ExportFLAC.cpp.

Referenced by Initialize().

---

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

• ExportFLAC.cpp