Class used to export MP3 files. More...

Collaboration diagram for MP3Exporter:

Public Types
enum	AskUser { No , Maybe , Yes }

Public Member Functions
	MP3Exporter ()

	~MP3Exporter ()

bool	FindLibrary (wxWindow *parent)

bool	LoadLibrary (wxWindow *parent, AskUser askuser)

bool	ValidLibraryLoaded ()

void	SetMode (int mode)

void	SetBitrate (int rate)

void	SetQuality (int q)

bool	InitLibrary (wxString libpath)

bool	InitLibraryInternal ()

bool	InitLibraryExternal (wxString libpath)

void	FreeLibrary ()

wxString	GetLibraryVersion ()

wxString	GetLibraryName ()

wxString	GetLibraryPath ()

FileNames::FileTypes	GetLibraryTypes ()

int	InitializeStream (unsigned channels, int sampleRate)

int	GetOutBufferSize ()

int	EncodeBuffer (float inbuffer[], unsigned char outbuffer[])

int	EncodeRemainder (float inbuffer[], int nSamples, unsigned char outbuffer[])

int	EncodeBufferMono (float inbuffer[], unsigned char outbuffer[])

int	EncodeRemainderMono (float inbuffer[], int nSamples, unsigned char outbuffer[])

int	FinishStream (unsigned char outbuffer[])

void	CancelEncoding ()

bool	PutInfoTag (wxFFile &f, wxFileOffset off)

Private Attributes
bool	mLibIsExternal

wxString	mLibPath

wxDynamicLibrary	lame_lib

bool	mLibraryLoaded

TranslatableString	mBladeVersion

bool	mEncoding

int	mMode

int	mBitrate

int	mQuality

lame_init_t *	lame_init

lame_init_params_t *	lame_init_params

lame_encode_buffer_ieee_float_t *	lame_encode_buffer_ieee_float

lame_encode_buffer_interleaved_ieee_float_t *	lame_encode_buffer_interleaved_ieee_float

lame_encode_flush_t *	lame_encode_flush

lame_close_t *	lame_close

get_lame_version_t *	get_lame_version

lame_set_in_samplerate_t *	lame_set_in_samplerate

lame_set_out_samplerate_t *	lame_set_out_samplerate

lame_set_num_channels_t *	lame_set_num_channels

lame_set_quality_t *	lame_set_quality

lame_set_brate_t *	lame_set_brate

lame_set_VBR_t *	lame_set_VBR

lame_set_VBR_q_t *	lame_set_VBR_q

lame_set_VBR_min_bitrate_kbps_t *	lame_set_VBR_min_bitrate_kbps

lame_set_mode_t *	lame_set_mode

lame_set_preset_t *	lame_set_preset

lame_set_error_protection_t *	lame_set_error_protection

lame_set_disable_reservoir_t *	lame_set_disable_reservoir

lame_set_bWriteVbrTag_t *	lame_set_bWriteVbrTag

lame_get_lametag_frame_t *	lame_get_lametag_frame

lame_mp3_tags_fid_t *	lame_mp3_tags_fid

beWriteInfoTag_t *	beWriteInfoTag

beVersion_t *	beVersion

lame_global_flags *	mGF

unsigned char	mInfoTagBuf [2880]

size_t	mInfoTagLen

Static Private Attributes
static const int	mSamplesPerChunk = 220500

static const int	mOutBufferSize

Detailed Description

Class used to export MP3 files.

Definition at line 692 of file ExportMP3.cpp.

Member Enumeration Documentation

◆ AskUser

enum MP3Exporter::AskUser

Enumerator
No
Maybe
Yes

Definition at line 695 of file ExportMP3.cpp.

   {
      No,
      Maybe,
      Yes
   };

Constructor & Destructor Documentation

◆ MP3Exporter()

MP3Exporter::MP3Exporter ( )

Definition at line 813 of file ExportMP3.cpp.

{
// We could use #defines rather than this variable.
// The idea of the variable is that if we wanted, we could allow
// a dynamic override of the library, e.g. with a newer faster version,
// or to fix CVEs in the underlying library.
// for now though the 'variable' is a constant.
#ifdef MP3_EXPORT_BUILT_IN
   mLibIsExternal = false;
#else
   mLibIsExternal = true;
#endif
 
#ifndef DISABLE_DYNAMIC_LOADING_LAME
   mLibraryLoaded = false;
#endif // DISABLE_DYNAMIC_LOADING_LAME
   mEncoding = false;
   mGF = NULL;
 
#ifndef DISABLE_DYNAMIC_LOADING_LAME
   if (gPrefs) {
      mLibPath = gPrefs->Read(wxT("/MP3/MP3LibPath"), wxT(""));
   }
#endif // DISABLE_DYNAMIC_LOADING_LAME
 
   mBitrate = 128;
   mQuality = QUALITY_2;
   mMode = MODE_CBR;
   //mRoutine = ROUTINE_FAST;
}

References gPrefs, mBitrate, mEncoding, mGF, mLibIsExternal, mLibPath, mLibraryLoaded, mMode, MODE_CBR, mQuality, QUALITY_2, audacity::BasicSettings::Read(), and wxT().

Here is the call graph for this function:

◆ ~MP3Exporter()

MP3Exporter::~MP3Exporter ( )

Definition at line 844 of file ExportMP3.cpp.

{
   FreeLibrary();
}

References FreeLibrary().

Here is the call graph for this function:

Member Function Documentation

◆ CancelEncoding()

void MP3Exporter::CancelEncoding ( )

Definition at line 1339 of file ExportMP3.cpp.

{
   mEncoding = false;
}

References mEncoding.

◆ EncodeBuffer()

int MP3Exporter::EncodeBuffer	(	float	inbuffer[],
		unsigned char	outbuffer[]
	)

Definition at line 1276 of file ExportMP3.cpp.

{
   if (!mEncoding) {
      return -1;
   }
 
   return lame_encode_buffer_interleaved_ieee_float(mGF, inbuffer, mSamplesPerChunk,
      outbuffer, mOutBufferSize);
}

References lame_encode_buffer_interleaved_ieee_float, mEncoding, mGF, mOutBufferSize, and mSamplesPerChunk.

Referenced by MP3ExportProcessor::Process().

Here is the caller graph for this function:

◆ EncodeBufferMono()

int MP3Exporter::EncodeBufferMono	(	float	inbuffer[],
		unsigned char	outbuffer[]
	)

Definition at line 1297 of file ExportMP3.cpp.

{
   if (!mEncoding) {
      return -1;
   }
 
   return lame_encode_buffer_ieee_float(mGF, inbuffer,inbuffer, mSamplesPerChunk,
      outbuffer, mOutBufferSize);
}

References lame_encode_buffer_ieee_float, mEncoding, mGF, mOutBufferSize, and mSamplesPerChunk.

Referenced by MP3ExportProcessor::Process().

Here is the caller graph for this function:

◆ EncodeRemainder()

int MP3Exporter::EncodeRemainder	(	float	inbuffer[],
		int	nSamples,
		unsigned char	outbuffer[]
	)

Definition at line 1286 of file ExportMP3.cpp.

{
   if (!mEncoding) {
      return -1;
   }
 
   return lame_encode_buffer_interleaved_ieee_float(mGF, inbuffer, nSamples, outbuffer,
      mOutBufferSize);
}

References lame_encode_buffer_interleaved_ieee_float, mEncoding, mGF, and mOutBufferSize.

Referenced by MP3ExportProcessor::Process().

Here is the caller graph for this function:

◆ EncodeRemainderMono()

int MP3Exporter::EncodeRemainderMono	(	float	inbuffer[],
		int	nSamples,
		unsigned char	outbuffer[]
	)

Definition at line 1307 of file ExportMP3.cpp.

{
   if (!mEncoding) {
      return -1;
   }
 
   return lame_encode_buffer_ieee_float(mGF, inbuffer, inbuffer, nSamples, outbuffer,
      mOutBufferSize);
}

References lame_encode_buffer_ieee_float, mEncoding, mGF, and mOutBufferSize.

Referenced by MP3ExportProcessor::Process().

Here is the caller graph for this function:

◆ FindLibrary()

bool MP3Exporter::FindLibrary ( wxWindow * parent )

Definition at line 851 of file ExportMP3.cpp.

{
   wxString path;
   wxString name;
 
   if (!mLibPath.empty()) {
      wxFileName fn = mLibPath;
      path = fn.GetPath();
      name = fn.GetFullName();
   }
   else {
      path = GetLibraryPath();
      name = GetLibraryName();
   }
 
   FindDialog fd(parent,
      path,
      name,
      GetLibraryTypes());
 
   if (fd.ShowModal() == wxID_CANCEL) {
      return false;
   }
 
   path = fd.GetLibPath();
 
   if (!::wxFileExists(path)) {
      return false;
   }
 
   mLibPath = path;
 
   return (gPrefs->Write(wxT("/MP3/MP3LibPath"), mLibPath) && gPrefs->Flush());
}

References audacity::BasicSettings::Flush(), fn, FindDialog::GetLibPath(), GetLibraryName(), GetLibraryPath(), GetLibraryTypes(), gPrefs, mLibPath, name, audacity::BasicSettings::Write(), and wxT().

Referenced by GetMP3Version(), and LoadLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FinishStream()

int MP3Exporter::FinishStream ( unsigned char outbuffer[] )

Definition at line 1318 of file ExportMP3.cpp.

{
   if (!mEncoding) {
      return -1;
   }
 
   mEncoding = false;
 
   int result = lame_encode_flush(mGF, outbuffer, mOutBufferSize);
 
#if defined(DISABLE_DYNAMIC_LOADING_LAME)
   mInfoTagLen = lame_get_lametag_frame(mGF, mInfoTagBuf, sizeof(mInfoTagBuf));
#else
   if (lame_get_lametag_frame) {
      mInfoTagLen = lame_get_lametag_frame(mGF, mInfoTagBuf, sizeof(mInfoTagBuf));
   }
#endif
 
   return result;
}

References lame_encode_flush, lame_get_lametag_frame, mEncoding, mGF, mInfoTagBuf, mInfoTagLen, and mOutBufferSize.

Referenced by MP3ExportProcessor::Process().

Here is the caller graph for this function:

◆ FreeLibrary()

void MP3Exporter::FreeLibrary ( )

Definition at line 1145 of file ExportMP3.cpp.

{
   if (mGF) {
      lame_close(mGF);
      mGF = NULL;
   }
 
#ifndef DISABLE_DYNAMIC_LOADING_LAME
   lame_lib.Unload();
#endif // DISABLE_DYNAMIC_LOADING_LAME
 
   return;
}

References lame_close, lame_lib, and mGF.

Referenced by LoadLibrary(), and ~MP3Exporter().

Here is the caller graph for this function:

◆ GetLibraryName()

wxString MP3Exporter::GetLibraryName ( )

Definition at line 1395 of file ExportMP3.cpp.

{
   return wxT("lame_enc.dll");
}

References wxT().

Referenced by FindLibrary(), and LoadLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLibraryPath()

wxString MP3Exporter::GetLibraryPath ( )

Definition at line 1377 of file ExportMP3.cpp.

{
   wxRegKey reg(wxT("HKEY_LOCAL_MACHINE\\Software\\Lame for Audacity"));
   wxString path;
 
   if (reg.Exists()) {
      wxLogMessage(wxT("LAME registry key exists."));
      reg.QueryValue(wxT("InstallPath"), path);
   }
   else {
      wxLogMessage(wxT("LAME registry key does not exist."));
   }
 
   wxLogMessage(wxT("Library path is: ") + path);
 
   return path;
}

References anonymous_namespace{CompareAudioCommand.cpp}::reg, and wxT().

Referenced by FindLibrary(), and LoadLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLibraryTypes()

FileNames::FileTypes MP3Exporter::GetLibraryTypes ( )

Definition at line 1400 of file ExportMP3.cpp.

{
   return {
      { XO("Only lame_enc.dll"), { wxT("lame_enc.dll") } },
      FileNames::DynamicLibraries,
      FileNames::AllFiles
   };
}

References FileNames::AllFiles, FileNames::DynamicLibraries, wxT(), and XO().

Referenced by FindLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLibraryVersion()

wxString MP3Exporter::GetLibraryVersion ( )

Definition at line 1159 of file ExportMP3.cpp.

{
#ifndef DISABLE_DYNAMIC_LOADING_LAME
   if (!mLibraryLoaded) {
      return wxT("");
   }
#endif // DISABLE_DYNAMIC_LOADING_LAME
 
   return wxString::Format(wxT("LAME %hs"), get_lame_version());
}

References get_lame_version, mLibraryLoaded, and wxT().

Referenced by GetMP3Version().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOutBufferSize()

int MP3Exporter::GetOutBufferSize ( )

Definition at line 1268 of file ExportMP3.cpp.

{
   if (!mEncoding)
      return -1;
 
   return mOutBufferSize;
}

References mEncoding, and mOutBufferSize.

Referenced by MP3ExportProcessor::Initialize().

Here is the caller graph for this function:

◆ InitializeStream()

int MP3Exporter::InitializeStream	(	unsigned	channels,
		int	sampleRate
	)

Definition at line 1170 of file ExportMP3.cpp.

{
#ifndef DISABLE_DYNAMIC_LOADING_LAME
   if (!mLibraryLoaded) {
      return -1;
   }
#endif // DISABLE_DYNAMIC_LOADING_LAME
 
   if (channels > 2) {
      return -1;
   }
 
   lame_set_error_protection(mGF, false);
   lame_set_num_channels(mGF, channels);
   lame_set_in_samplerate(mGF, sampleRate);
   lame_set_out_samplerate(mGF, sampleRate);
   lame_set_disable_reservoir(mGF, false);
   // Add the VbrTag for all types.  For ABR/VBR, a Xing tag will be created.
   // For CBR, it will be a Lame Info tag.
   lame_set_bWriteVbrTag(mGF, true);
 
   // Set the VBR quality or ABR/CBR bitrate
   switch (mMode) {
      case MODE_SET:
      {
         int preset;
 
         if (mQuality == PRESET_INSANE) {
            preset = INSANE;
         }
         //else if (mRoutine == ROUTINE_FAST) {
            else if (mQuality == PRESET_EXTREME) {
               preset = EXTREME_FAST;
            }
            else if (mQuality == PRESET_STANDARD) {
               preset = STANDARD_FAST;
            }
            else {
               preset = 1007;    // Not defined until 3.96
            }
         //}
         /*
         else {
            if (mQuality == PRESET_EXTREME) {
               preset = EXTREME;
            }
            else if (mQuality == PRESET_STANDARD) {
               preset = STANDARD;
            }
            else {
               preset = 1006;    // Not defined until 3.96
            }
         }
         */
         lame_set_preset(mGF, preset);
      }
      break;
 
      case MODE_VBR:
         lame_set_VBR(mGF, vbr_mtrh );
         lame_set_VBR_q(mGF, mQuality);
      break;
 
      case MODE_ABR:
         lame_set_preset(mGF, mBitrate );
      break;
 
      default:
         lame_set_VBR(mGF, vbr_off);
         lame_set_brate(mGF, mBitrate);
      break;
   }
 
   // Set the channel mode
   MPEG_mode mode;
 
   if (channels == 1)
      mode = MONO;
   else
      mode = JOINT_STEREO;
 
   lame_set_mode(mGF, mode);
 
   int rc = lame_init_params(mGF);
   if (rc < 0) {
      return rc;
   }
 
#if 0
   dump_config(mGF);
#endif
 
   mInfoTagLen = 0;
   mEncoding = true;
 
   return mSamplesPerChunk;
}

References lame_init_params, lame_set_brate, lame_set_bWriteVbrTag, lame_set_disable_reservoir, lame_set_error_protection, lame_set_in_samplerate, lame_set_mode, lame_set_num_channels, lame_set_out_samplerate, lame_set_preset, lame_set_VBR, lame_set_VBR_q, mBitrate, mEncoding, mGF, mInfoTagLen, mLibraryLoaded, mMode, MODE_ABR, MODE_SET, MODE_VBR, mQuality, mSamplesPerChunk, preset, PRESET_EXTREME, PRESET_INSANE, PRESET_STANDARD, and anonymous_namespace{ClipSegmentTest.cpp}::sampleRate.

Referenced by MP3ExportProcessor::Initialize().

Here is the caller graph for this function:

◆ InitLibrary()

bool MP3Exporter::InitLibrary ( wxString libpath )

Definition at line 971 of file ExportMP3.cpp.

{
   return mLibIsExternal ? InitLibraryExternal(libpath) : InitLibraryInternal();
}

References InitLibraryExternal(), InitLibraryInternal(), and mLibIsExternal.

Referenced by MP3ExportProcessor::Initialize(), and LoadLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitLibraryExternal()

bool MP3Exporter::InitLibraryExternal ( wxString libpath )

Definition at line 1028 of file ExportMP3.cpp.

{
   wxLogMessage(wxT("Loading LAME from %s"), libpath);
 
#ifndef DISABLE_DYNAMIC_LOADING_LAME
   if (!lame_lib.Load(libpath, wxDL_LAZY)) {
      wxLogMessage(wxT("load failed"));
      return false;
   }
 
   wxLogMessage(wxT("Actual LAME path %s"),
              FileNames::PathFromAddr(lame_lib.GetSymbol(wxT("lame_init"))));
 
   lame_init = (lame_init_t *)
      lame_lib.GetSymbol(wxT("lame_init"));
   get_lame_version = (get_lame_version_t *)
      lame_lib.GetSymbol(wxT("get_lame_version"));
   lame_init_params = (lame_init_params_t *)
      lame_lib.GetSymbol(wxT("lame_init_params"));
   lame_encode_buffer_ieee_float = (lame_encode_buffer_ieee_float_t *)
      lame_lib.GetSymbol(wxT("lame_encode_buffer_ieee_float"));
   lame_encode_buffer_interleaved_ieee_float = (lame_encode_buffer_interleaved_ieee_float_t *)
      lame_lib.GetSymbol(wxT("lame_encode_buffer_interleaved_ieee_float"));
   lame_encode_flush = (lame_encode_flush_t *)
      lame_lib.GetSymbol(wxT("lame_encode_flush"));
   lame_close = (lame_close_t *)
      lame_lib.GetSymbol(wxT("lame_close"));
 
   lame_set_in_samplerate = (lame_set_in_samplerate_t *)
       lame_lib.GetSymbol(wxT("lame_set_in_samplerate"));
   lame_set_out_samplerate = (lame_set_out_samplerate_t *)
       lame_lib.GetSymbol(wxT("lame_set_out_samplerate"));
   lame_set_num_channels = (lame_set_num_channels_t *)
       lame_lib.GetSymbol(wxT("lame_set_num_channels"));
   lame_set_quality = (lame_set_quality_t *)
       lame_lib.GetSymbol(wxT("lame_set_quality"));
   lame_set_brate = (lame_set_brate_t *)
       lame_lib.GetSymbol(wxT("lame_set_brate"));
   lame_set_VBR = (lame_set_VBR_t *)
       lame_lib.GetSymbol(wxT("lame_set_VBR"));
   lame_set_VBR_q = (lame_set_VBR_q_t *)
       lame_lib.GetSymbol(wxT("lame_set_VBR_q"));
   lame_set_VBR_min_bitrate_kbps = (lame_set_VBR_min_bitrate_kbps_t *)
       lame_lib.GetSymbol(wxT("lame_set_VBR_min_bitrate_kbps"));
   lame_set_mode = (lame_set_mode_t *)
       lame_lib.GetSymbol(wxT("lame_set_mode"));
   lame_set_preset = (lame_set_preset_t *)
       lame_lib.GetSymbol(wxT("lame_set_preset"));
   lame_set_error_protection = (lame_set_error_protection_t *)
       lame_lib.GetSymbol(wxT("lame_set_error_protection"));
   lame_set_disable_reservoir = (lame_set_disable_reservoir_t *)
       lame_lib.GetSymbol(wxT("lame_set_disable_reservoir"));
   lame_set_bWriteVbrTag = (lame_set_bWriteVbrTag_t *)
       lame_lib.GetSymbol(wxT("lame_set_bWriteVbrTag"));
 
   // These are optional
   lame_get_lametag_frame = (lame_get_lametag_frame_t *)
       lame_lib.GetSymbol(wxT("lame_get_lametag_frame"));
   lame_mp3_tags_fid = (lame_mp3_tags_fid_t *)
       lame_lib.GetSymbol(wxT("lame_mp3_tags_fid"));
#if defined(__WXMSW__)
   beWriteInfoTag = (beWriteInfoTag_t *)
       lame_lib.GetSymbol(wxT("beWriteInfoTag"));
   beVersion = (beVersion_t *)
       lame_lib.GetSymbol(wxT("beVersion"));
#endif
 
   if (!lame_init ||
      !get_lame_version ||
      !lame_init_params ||
      !lame_encode_buffer_ieee_float ||
      !lame_encode_buffer_interleaved_ieee_float ||
      !lame_encode_flush ||
      !lame_close ||
      !lame_set_in_samplerate ||
      !lame_set_out_samplerate ||
      !lame_set_num_channels ||
      !lame_set_quality ||
      !lame_set_brate ||
      !lame_set_VBR ||
      !lame_set_VBR_q ||
      !lame_set_mode ||
      !lame_set_preset ||
      !lame_set_error_protection ||
      !lame_set_disable_reservoir ||
      !lame_set_bWriteVbrTag)
   {
      wxLogMessage(wxT("Failed to find a required symbol in the LAME library."));
#if defined(__WXMSW__)
      if (beVersion) {
         be_version v;
         beVersion(&v);
 
         mBladeVersion = XO(
"You are linking to lame_enc.dll v%d.%d. This version is not compatible with Audacity %d.%d.%d.\nPlease download the latest version of 'LAME for Audacity'.")
            .Format(
               v.byMajorVersion,
               v.byMinorVersion,
               AUDACITY_VERSION,
               AUDACITY_RELEASE,
               AUDACITY_REVISION);
      }
#endif
 
      lame_lib.Unload();
      return false;
   }
#endif // DISABLE_DYNAMIC_LOADING_LAME
 
   mGF = lame_init();
   if (mGF == NULL) {
      return false;
   }
 
   return true;
}

References beVersion, beWriteInfoTag, be_version::byMajorVersion, be_version::byMinorVersion, get_lame_version, lame_close, lame_encode_buffer_ieee_float, lame_encode_buffer_interleaved_ieee_float, lame_encode_flush, lame_get_lametag_frame, lame_init, lame_init_params, lame_lib, lame_mp3_tags_fid, lame_set_brate, lame_set_bWriteVbrTag, lame_set_disable_reservoir, lame_set_error_protection, lame_set_in_samplerate, lame_set_mode, lame_set_num_channels, lame_set_out_samplerate, lame_set_preset, lame_set_quality, lame_set_VBR, lame_set_VBR_min_bitrate_kbps, lame_set_VBR_q, mBladeVersion, mGF, FileNames::PathFromAddr(), wxT(), and XO().

Referenced by InitLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitLibraryInternal()

bool MP3Exporter::InitLibraryInternal ( )

Definition at line 976 of file ExportMP3.cpp.

{
   wxLogMessage(wxT("Using internal LAME"));
 
// The global ::lame_something symbols only exist if LAME is built in.
// So we don't reference them unless they are.
#ifdef MP3_EXPORT_BUILT_IN
 
   lame_init = ::lame_init;
   get_lame_version = ::get_lame_version;
   lame_init_params = ::lame_init_params;
   lame_encode_buffer_ieee_float = ::lame_encode_buffer_ieee_float;
   lame_encode_buffer_interleaved_ieee_float = ::lame_encode_buffer_interleaved_ieee_float;
   lame_encode_flush = ::lame_encode_flush;
   lame_close = ::lame_close;
 
   lame_set_in_samplerate = ::lame_set_in_samplerate;
   lame_set_out_samplerate = ::lame_set_out_samplerate;
   lame_set_num_channels = ::lame_set_num_channels;
   lame_set_quality = ::lame_set_quality;
   lame_set_brate = ::lame_set_brate;
   lame_set_VBR = ::lame_set_VBR;
   lame_set_VBR_q = ::lame_set_VBR_q;
   lame_set_VBR_min_bitrate_kbps = ::lame_set_VBR_min_bitrate_kbps;
   lame_set_mode = ::lame_set_mode;
   lame_set_preset = ::lame_set_preset;
   lame_set_error_protection = ::lame_set_error_protection;
   lame_set_disable_reservoir = ::lame_set_disable_reservoir;
   lame_set_bWriteVbrTag = ::lame_set_bWriteVbrTag;
 
   // These are optional
   //lame_get_lametag_frame = ::lame_get_lametag_frame;
   lame_get_lametag_frame = NULL;
   lame_mp3_tags_fid = ::lame_mp3_tags_fid;
 
#if defined(__WXMSW__)
   //beWriteInfoTag = ::beWriteInfoTag;
   //beVersion = ::beVersion;
   beWriteInfoTag = NULL;
   beVersion = NULL;
#endif
 
   mGF = lame_init();
   if (mGF == NULL) {
      return false;
   }
#endif
 
   return true;
}

References beVersion, beWriteInfoTag, get_lame_version, lame_close, lame_encode_buffer_ieee_float, lame_encode_buffer_interleaved_ieee_float, lame_encode_flush, lame_get_lametag_frame, lame_init, lame_init_params, lame_mp3_tags_fid, lame_set_brate, lame_set_bWriteVbrTag, lame_set_disable_reservoir, lame_set_error_protection, lame_set_in_samplerate, lame_set_mode, lame_set_num_channels, lame_set_out_samplerate, lame_set_preset, lame_set_quality, lame_set_VBR, lame_set_VBR_min_bitrate_kbps, lame_set_VBR_q, mGF, and wxT().

Referenced by InitLibrary(), and LoadLibrary().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadLibrary()

bool MP3Exporter::LoadLibrary	(	wxWindow *	parent,
		AskUser	askuser
	)

Definition at line 886 of file ExportMP3.cpp.

{
 
   if (ValidLibraryLoaded()) {
      FreeLibrary();
      mLibraryLoaded = false;
   }
 
#if defined(__WXMSW__)
   mBladeVersion = {};
#endif
 
   if( !mLibIsExternal ){
      mLibraryLoaded = InitLibraryInternal();
      return mLibraryLoaded;
   }
 
   // First try loading it from a previously located path
   if (!mLibPath.empty()) {
      wxLogMessage(wxT("Attempting to load LAME from previously defined path"));
      mLibraryLoaded = InitLibrary(mLibPath);
   }
 
   // If not successful, try loading using system search paths
   if (!ValidLibraryLoaded()) {
      wxLogMessage(wxT("Attempting to load LAME from system search paths"));
      mLibPath = GetLibraryName();
      mLibraryLoaded = InitLibrary(mLibPath);
   }
 
   // If not successful, try loading using compiled in path
   if (!ValidLibraryLoaded()) {
      wxLogMessage(wxT("Attempting to load LAME from builtin path"));
      wxFileName fn(GetLibraryPath(), GetLibraryName());
      mLibPath = fn.GetFullPath();
      mLibraryLoaded = InitLibrary(mLibPath);
   }
 
   // If not successful, must ask the user
   if (!ValidLibraryLoaded()) {
      wxLogMessage(wxT("(Maybe) ask user for library"));
      if (askuser == MP3Exporter::Maybe && FindLibrary(parent)) {
         mLibraryLoaded = InitLibrary(mLibPath);
      }
   }
 
   // Oh well, just give up
   if (!ValidLibraryLoaded()) {
#if defined(__WXMSW__)
      if (askuser && !mBladeVersion.empty()) {
         BasicUI::ShowMessageBox(mBladeVersion);
      }
#endif
      wxLogMessage(wxT("Failed to locate LAME library"));
 
      return false;
   }
 
   wxLogMessage(wxT("LAME library successfully loaded"));
 
   return true;
}

References TranslatableString::empty(), FindLibrary(), fn, FreeLibrary(), GetLibraryName(), GetLibraryPath(), InitLibrary(), InitLibraryInternal(), Maybe, mBladeVersion, mLibIsExternal, mLibPath, mLibraryLoaded, BasicUI::ShowMessageBox(), ValidLibraryLoaded(), and wxT().

Referenced by ExportMP3::CheckFileName(), GetMP3Version(), and MP3ExportProcessor::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PutInfoTag()

bool MP3Exporter::PutInfoTag	(	wxFFile &	f,
		wxFileOffset	off
	)

Definition at line 1344 of file ExportMP3.cpp.

{
   if (mGF) {
      if (mInfoTagLen > 0) {
         // FIXME: TRAP_ERR Seek and writ ein MP3 exporter could fail.
         if ( !f.Seek(off, wxFromStart))
            return false;
         if (mInfoTagLen > f.Write(mInfoTagBuf, mInfoTagLen))
            return false;
      }
#if defined(__WXMSW__)
      else if (beWriteInfoTag) {
         if ( !f.Flush() )
            return false;
         // PRL:  What is the correct error check on the return value?
         beWriteInfoTag(mGF, OSOUTPUT(f.GetName()));
         mGF = NULL;
      }
#endif
      else if (lame_mp3_tags_fid != NULL) {
         lame_mp3_tags_fid(mGF, f.fp());
      }
   }
 
   if ( !f.SeekEnd() )
      return false;
 
   return true;
}