MP3ExportProcessor Class Reference

Inheritance diagram for MP3ExportProcessor:

Collaboration diagram for MP3ExportProcessor:

Public Member Functions
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	AskResample (int bitrate, int rate, int lowrate, int highrate)
static unsigned long	AddTags (ArrayOf< char > &buffer, bool *endOfFile, const Tags *tags)

Private Attributes
struct {
TranslatableString   status
unsigned   channels
double   t0
double   t1
MP3Exporter   exporter
wxFFile   outFile
ArrayOf< char >   id3buffer
unsigned long   id3len
wxFileOffset   infoTagPos
size_t   bufferSize
int   inSamples
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 1589 of file ExportMP3.cpp.

Member Function Documentation

AddTags()

unsigned long MP3ExportProcessor::AddTags ( ArrayOf< char > &  buffer, bool *  endOfFile, const Tags *  tags  )

staticprivate

Definition at line 2120 of file ExportMP3.cpp.

{
#ifdef USE_LIBID3TAG
   id3_tag_holder tp { id3_tag_new() };
 
   for (const auto &pair : tags->GetRange()) {
      const auto &n = pair.first;
      const auto &v = pair.second;
      const char *name = "TXXX";
 
      if (n.CmpNoCase(TAG_TITLE) == 0) {
         name = ID3_FRAME_TITLE;
      }
      else if (n.CmpNoCase(TAG_ARTIST) == 0) {
         name = ID3_FRAME_ARTIST;
      }
      else if (n.CmpNoCase(TAG_ALBUM) == 0) {
         name = ID3_FRAME_ALBUM;
      }
      else if (n.CmpNoCase(TAG_YEAR) == 0) {
         // LLL:  Some apps do not like the newer frame ID (ID3_FRAME_YEAR),
         //       so we add old one as well.
         AddFrame(tp.get(), n, v, "TYER");
         name = ID3_FRAME_YEAR;
      }
      else if (n.CmpNoCase(TAG_GENRE) == 0) {
         name = ID3_FRAME_GENRE;
      }
      else if (n.CmpNoCase(TAG_COMMENTS) == 0) {
         name = ID3_FRAME_COMMENT;
      }
      else if (n.CmpNoCase(TAG_TRACK) == 0) {
         name = ID3_FRAME_TRACK;
      }
 
      AddFrame(tp.get(), n, v, name);
   }
 
   tp->options &= (~ID3_TAG_OPTION_COMPRESSION); // No compression
 
   // If this version of libid3tag supports it, use v2.3 ID3
   // tags instead of the newer, but less well supported, v2.4
   // that libid3tag uses by default.
   #ifdef ID3_TAG_HAS_TAG_OPTION_ID3V2_3
   tp->options |= ID3_TAG_OPTION_ID3V2_3;
   #endif
 
   *endOfFile = false;
 
   unsigned long len;
 
   len = id3_tag_render(tp.get(), 0);
   buffer.reinit(len);
   len = id3_tag_render(tp.get(), (id3_byte_t *)buffer.get());
 
   return len;
#else //ifdef USE_LIBID3TAG
   return 0;
#endif
}

References Tags::GetRange(), name, ArrayOf< X >::reinit(), TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, and TAG_YEAR.

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

AskResample()

int MP3ExportProcessor::AskResample ( int  bitrate, int  rate, int  lowrate, int  highrate  )

staticprivate

Definition at line 2045 of file ExportMP3.cpp.

{
   wxDialogWrapper d(nullptr, wxID_ANY, XO("Invalid sample rate"));
   d.SetName();
   wxChoice *choice;
   ShuttleGui S(&d, eIsCreating);
 
   int selected = -1;
 
   S.StartVerticalLay();
   {
      S.SetBorder(10);
      S.StartStatic(XO("Resample"));
      {
         S.StartHorizontalLay(wxALIGN_CENTER, false);
         {
            S.AddTitle(
               ((bitrate == 0)
                  ? XO(
"The project sample rate (%d) is not supported by the MP3\nfile format. ")
                       .Format( rate )
                  : XO(
"The project sample rate (%d) and bit rate (%d kbps) combination is not\nsupported by the MP3 file format. ")
                       .Format( rate, bitrate ))
               + XO("You may resample to one of the rates below.")
            );
         }
         S.EndHorizontalLay();
 
         S.StartHorizontalLay(wxALIGN_CENTER, false);
         {
            choice = S.AddChoice(XXO("Sample Rates"),
               [&]{
                  TranslatableStrings choices;
                  for (size_t ii = 0, nn = sampRates.size(); ii < nn; ++ii) {
                     int label = sampRates[ii];
                     if (label >= lowrate && label <= highrate) {
                        choices.push_back( Verbatim( "%d" ).Format( label ) );
                        if (label <= rate)
                           selected = ii;
                     }
                  }
                  return choices;
               }(),
               std::max( 0, selected )
            );
         }
         S.EndHorizontalLay();
      }
      S.EndStatic();
 
      S.AddStandardButtons();
   }
   S.EndVerticalLay();
 
   d.Layout();
   d.Fit();
   d.SetMinSize(d.GetSize());
   d.Center();
 
   if (d.ShowModal() == wxID_CANCEL) {
      return 0;
   }
 
   return wxAtoi(choice->GetStringSelection());
}

References eIsCreating, S, sampRates, wxDialogWrapper::SetName(), XO(), and XXO().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

bool MP3ExportProcessor::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 1773 of file ExportMP3.cpp.

{
   context.t0 = t0;
   context.t1 = t1;
   context.channels = channels;
 
   int rate = lrint(sampleRate);
   auto& exporter = context.exporter;
 
#ifdef DISABLE_DYNAMIC_LOADING_LAME
   if (!exporter.InitLibrary(wxT(""))) {
      gPrefs->Write(wxT("/MP3/MP3LibPath"), wxString(wxT("")));
      gPrefs->Flush();
      throw ExportException(_("Could not initialize MP3 encoding library!"));
   }
#else
   if (!exporter.LoadLibrary(nullptr, MP3Exporter::Maybe)) {
      gPrefs->Write(wxT("/MP3/MP3LibPath"), wxString(wxT("")));
      gPrefs->Flush();
      throw ExportException(_("Could not open MP3 encoding library!"));
   }
 
   if (!exporter.ValidLibraryLoaded()) {
      gPrefs->Write(wxT("/MP3/MP3LibPath"), wxString(wxT("")));
      gPrefs->Flush();
      throw ExportException(_("Not a valid or supported MP3 encoding library!"));
   }
#endif // DISABLE_DYNAMIC_LOADING_LAME
 
   // Retrieve preferences
   int highrate = 48000;
   int lowrate = 8000;
   int bitrate = 0;
   int quality;
 
   auto rmode = ExportPluginHelpers::GetParameterValue(
      parameters,
      MP3OptionIDMode,
      std::string("CBR"));
   // Set the bitrate/quality and mode
   if (rmode == "SET") {
      quality = ExportPluginHelpers::GetParameterValue<int>(
         parameters,
         MP3OptionIDQualitySET,
         PRESET_STANDARD);
      exporter.SetMode(MODE_SET);
      exporter.SetQuality(quality);
   }
   else if (rmode == "VBR") {
      quality = ExportPluginHelpers::GetParameterValue<int>(
         parameters,
         MP3OptionIDQualityVBR,
         QUALITY_2);
      exporter.SetMode(MODE_VBR);
      exporter.SetQuality(quality);
   }
   else if (rmode == "ABR") {
      bitrate = ExportPluginHelpers::GetParameterValue(
         parameters,
         MP3OptionIDQualityABR,
         128);
      exporter.SetMode(MODE_ABR);
      exporter.SetBitrate(bitrate);
      if (bitrate > 160) {
         lowrate = 32000;
      }
      else if (bitrate < 32 || bitrate == 144) {
         highrate = 24000;
      }
   }
   else {
      bitrate = ExportPluginHelpers::GetParameterValue(parameters, MP3OptionIDQualityCBR, 128);
      exporter.SetMode(MODE_CBR);
      exporter.SetBitrate(bitrate);
 
      if (bitrate > 160) {
         lowrate = 32000;
      }
      else if (bitrate < 32 || bitrate == 144) {
         highrate = 24000;
      }
   }
 
   // Verify sample rate
   if (!make_iterator_range( sampRates ).contains( rate ) ||
      (rate < lowrate) || (rate > highrate)) {
        // Force valid sample rate in macros.
      if (project.mBatchMode) {
         if (!make_iterator_range( sampRates ).contains( rate )) {
            auto const bestRateIt = std::lower_bound(sampRates.begin(),
            sampRates.end(), rate);
            rate = (bestRateIt == sampRates.end()) ? highrate : *bestRateIt;
         }
         if (rate < lowrate) {
            rate = lowrate;
         }
         else if (rate > highrate) {
            rate = highrate;
         }
      }
      // else validate or prompt
      else {
         if (!make_iterator_range( sampRates ).contains( rate ) ||
            (rate < lowrate) || (rate > highrate)) {
            //This call should go away once export project rate option
            //is available as an export dialog option
            rate = AskResample(bitrate, rate, lowrate, highrate);
         }
         if (rate == 0) {
            return false;
         }
      }
   }
 
   context.inSamples = exporter.InitializeStream(channels, rate);
   if (context.inSamples < 0) {
      throw ExportException(_("Unable to initialize MP3 stream"));
   }
 
   // Put ID3 tags at beginning of file
   if (metadata == nullptr)
      metadata = &Tags::Get( project );
 
   // Open file for writing
   if (!context.outFile.Open(fName.GetFullPath(), wxT("w+b"))) {
      throw ExportException(_("Unable to open target file for writing"));
   }
 
   bool endOfFile;
   context.id3len = AddTags(context.id3buffer, &endOfFile, metadata);
   if (context.id3len && !endOfFile) {
      if (context.id3len > context.outFile.Write(context.id3buffer.get(), context.id3len)) {
         // TODO: more precise message
         throw ExportErrorException("MP3:1882");
      }
      context.id3len = 0;
      context.id3buffer.reset();
   }
 
   context.infoTagPos = context.outFile.Tell();
 
   context.bufferSize = std::max(0, exporter.GetOutBufferSize());
   if (context.bufferSize == 0) {
      // TODO: more precise message
      throw ExportErrorException("MP3:1849");
   }
 
   if (rmode == "SET") {
      context.status = (selectionOnly ?
         XO("Exporting selected audio with %s preset") :
         XO("Exporting the audio with %s preset"))
            .Format( setRateNamesShort[quality] );
   }
   else if (rmode == "VBR") {
      context.status = (selectionOnly ?
         XO("Exporting selected audio with VBR quality %s") :
         XO("Exporting the audio with VBR quality %s"))
            .Format( varRateNames[quality] );
   }
   else {
      context.status = (selectionOnly ?
         XO("Exporting selected audio at %d Kbps") :
         XO("Exporting the audio at %d Kbps"))
            .Format( bitrate );
   }
 
   context.mixer = ExportPluginHelpers::CreateMixer(
      project, selectionOnly, t0, t1, channels, context.inSamples, true, rate,
      floatSample, mixerSpec);
 
   return true;
}

References _, AddTags(), AskResample(), channels, context, ExportPluginHelpers::CreateMixer(), exporter, floatSample, audacity::BasicSettings::Flush(), Tags::Get(), MP3Exporter::GetOutBufferSize(), ExportPluginHelpers::GetParameterValue(), gPrefs, MP3Exporter::InitializeStream(), MP3Exporter::InitLibrary(), MP3Exporter::LoadLibrary(), lrint, make_iterator_range(), MP3Exporter::Maybe, MODE_ABR, MODE_CBR, MODE_SET, MODE_VBR, MP3OptionIDMode, MP3OptionIDQualityABR, MP3OptionIDQualityCBR, MP3OptionIDQualitySET, MP3OptionIDQualityVBR, PRESET_STANDARD, project, QUALITY_2, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, sampRates, MP3Exporter::SetBitrate(), MP3Exporter::SetMode(), MP3Exporter::SetQuality(), setRateNamesShort, t0, t1, MP3Exporter::ValidLibraryLoaded(), varRateNames, audacity::BasicSettings::Write(), wxT(), and XO().

Here is the call graph for this function:

Process()

ExportResult MP3ExportProcessor::Process ( ExportProcessorDelegate &  delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 1952 of file ExportMP3.cpp.

{
   delegate.SetStatusString(context.status);
 
   auto& exporter = context.exporter;
   int bytes = 0;
 
   ArrayOf<unsigned char> buffer{ context.bufferSize };
   wxASSERT(buffer);
 
   auto exportResult = ExportResult::Success;
 
   {
      while (exportResult == ExportResult::Success) {
         auto blockLen = context.mixer->Process();
         if (blockLen == 0)
            break;
 
         float *mixed = (float *)context.mixer->GetBuffer();
 
         if ((int)blockLen < context.inSamples) {
            if (context.channels > 1) {
               bytes = exporter.EncodeRemainder(mixed, blockLen, buffer.get());
            }
            else {
               bytes = exporter.EncodeRemainderMono(mixed, blockLen, buffer.get());
            }
         }
         else {
            if (context.channels > 1) {
               bytes = exporter.EncodeBuffer(mixed, buffer.get());
            }
            else {
               bytes = exporter.EncodeBufferMono(mixed, buffer.get());
            }
         }
 
         if (bytes < 0) {
            throw ExportException(XO("Error %ld returned from MP3 encoder")
               .Format( bytes )
               .Translation());
         }
 
         if (bytes > (int)context.outFile.Write(buffer.get(), bytes)) {
            // TODO: more precise message
            throw ExportDiskFullError(context.outFile.GetName());
         }
 
         if(exportResult == ExportResult::Success)
            exportResult = ExportPluginHelpers::UpdateProgress(
               delegate, *context.mixer, context.t0, context.t1);
      }
   }
 
   if (exportResult == ExportResult::Success) {
      bytes = exporter.FinishStream(buffer.get());
 
      if (bytes < 0) {
         // TODO: more precise message
         throw ExportErrorException("MP3:1981");
      }
 
      if (bytes > 0) {
         if (bytes > (int)context.outFile.Write(buffer.get(), bytes)) {
            // TODO: more precise message
            throw ExportErrorException("MP3:1988");
         }
      }
 
      // Write ID3 tag if it was supposed to be at the end of the file
      if (context.id3len > 0) {
         if (bytes > (int)context.outFile.Write(context.id3buffer.get(), context.id3len)) {
            // TODO: more precise message
            throw ExportErrorException("MP3:1997");
         }
      }
 
      // Always write the info (Xing/Lame) tag.  Until we stop supporting Lame
      // versions before 3.98, we must do this after the MP3 file has been
      // closed.
      //
      // Also, if beWriteInfoTag() is used, mGF will no longer be valid after
      // this call, so do not use it.
      if (!exporter.PutInfoTag(context.outFile, context.infoTagPos) ||
          !context.outFile.Flush() ||
          !context.outFile.Close()) {
         // TODO: more precise message
         throw ExportErrorException("MP3:2012");
      }
   }
   return exportResult;
}

References context, MP3Exporter::EncodeBuffer(), MP3Exporter::EncodeBufferMono(), MP3Exporter::EncodeRemainder(), MP3Exporter::EncodeRemainderMono(), exporter, MP3Exporter::FinishStream(), MP3Exporter::PutInfoTag(), ExportProcessorDelegate::SetStatusString(), Success, ExportPluginHelpers::UpdateProgress(), and XO().

Here is the call graph for this function:

Member Data Documentation

bufferSize

size_t MP3ExportProcessor::bufferSize

Definition at line 1602 of file ExportMP3.cpp.

channels

unsigned MP3ExportProcessor::channels

Definition at line 1594 of file ExportMP3.cpp.

Referenced by Initialize().

struct { ... } MP3ExportProcessor::context

Referenced by Initialize(), and Process().

exporter

MP3Exporter MP3ExportProcessor::exporter

Definition at line 1597 of file ExportMP3.cpp.

Referenced by Initialize(), and Process().

id3buffer

ArrayOf<char> MP3ExportProcessor::id3buffer

Definition at line 1599 of file ExportMP3.cpp.

id3len

unsigned long MP3ExportProcessor::id3len

Definition at line 1600 of file ExportMP3.cpp.

infoTagPos

wxFileOffset MP3ExportProcessor::infoTagPos

Definition at line 1601 of file ExportMP3.cpp.

inSamples

int MP3ExportProcessor::inSamples

Definition at line 1603 of file ExportMP3.cpp.

mixer

std::unique_ptr<Mixer> MP3ExportProcessor::mixer

Definition at line 1604 of file ExportMP3.cpp.

outFile

wxFFile MP3ExportProcessor::outFile

Definition at line 1598 of file ExportMP3.cpp.

status

TranslatableString MP3ExportProcessor::status

Definition at line 1593 of file ExportMP3.cpp.

t0

double MP3ExportProcessor::t0

Definition at line 1595 of file ExportMP3.cpp.

Referenced by Initialize().

t1

double MP3ExportProcessor::t1

Definition at line 1596 of file ExportMP3.cpp.

Referenced by Initialize().

---

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

• ExportMP3.cpp