Custom FFmpeg export dialog. More...

#include <ExportFFmpegOptions.h>

Inheritance diagram for ExportFFmpegOptions:

Collaboration diagram for ExportFFmpegOptions:

Public Member Functions
	ExportFFmpegOptions (wxWindow *parent)

	~ExportFFmpegOptions ()

void	PopulateOrExchange (ShuttleGui &S)

void	OnOK (wxCommandEvent &event)

void	OnGetURL (wxCommandEvent &event)

void	OnFormatList (wxCommandEvent &event)

void	DoOnFormatList ()

void	OnCodecList (wxCommandEvent &event)

void	DoOnCodecList ()

void	OnAllFormats (wxCommandEvent &event)

void	OnAllCodecs (wxCommandEvent &event)

void	OnSavePreset (wxCommandEvent &event)

void	OnLoadPreset (wxCommandEvent &event)

void	OnDeletePreset (wxCommandEvent &event)

void	OnImportPresets (wxCommandEvent &event)

void	OnExportPresets (wxCommandEvent &event)

bool	SavePreset (bool bCheckForOverwrite)

Public Member Functions inherited from wxDialogWrapper
	wxDialogWrapper ()

	wxDialogWrapper (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))

bool	Create (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))

void	SetTitle (const TranslatableString &title)

void	SetLabel (const TranslatableString &title)

void	SetName (const TranslatableString &title)

void	SetName ()

Public Member Functions inherited from wxTabTraversalWrapper< wxDialog >
	wxTabTraversalWrapper (Args &&... args)

	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete

	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete

wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete

wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

Static Public Attributes
static CompatibilityEntry	CompatibilityList []

static ExposedFormat	fmts []
	List of export types. More...

static const int	iAACSampleRates []

static ApplicableFor	apptable []

Private Member Functions
void	FindSelectedFormat (wxString name, wxString longname)
	Finds the format currently selected and returns its name and description. More...

void	FindSelectedCodec (wxString name, wxString longname)
	Finds the codec currently selected and returns its name and description. More...

void	FetchFormatList ()
	Retrieves format list from libavformat. More...

int	FetchCompatibleFormatList (AudacityAVCodecID id, wxString *selfmt)

void	FetchCodecList ()
	Retrieves codec list from libavcodec. More...

int	FetchCompatibleCodecList (const wxChar *fmt, AudacityAVCodecID id)

void	FetchPresetList ()
	Retrieves list of presets from configuration file. More...

bool	ReportIfBadCombination ()

void	EnableDisableControls (AVCodecWrapper cdc, wxString selfmt)

Private Attributes
wxArrayString	mShownFormatNames

wxArrayString	mShownFormatLongNames

wxArrayString	mShownCodecNames

wxArrayString	mShownCodecLongNames

wxArrayStringEx	mFormatNames

wxArrayString	mFormatLongNames

wxArrayStringEx	mCodecNames

wxArrayString	mCodecLongNames

wxListBox *	mFormatList

wxListBox *	mCodecList

wxStaticText *	mFormatName

wxStaticText *	mCodecName

wxComboBox *	mPresetCombo

int	mBitRateFromChoice

int	mSampleRateFromChoice

std::unique_ptr< FFmpegPresets >	mPresets

wxArrayStringEx	mPresetNames

std::shared_ptr< FFmpegFunctions >	mFFmpeg

Detailed Description

Custom FFmpeg export dialog.

Definition at line 73 of file ExportFFmpegOptions.h.

Constructor & Destructor Documentation

◆ ExportFFmpegOptions()

ExportFFmpegOptions::ExportFFmpegOptions ( wxWindow * parent )

Definition at line 477 of file ExportFFmpegOptions.cpp.

:  wxDialogWrapper(parent, wxID_ANY,
            XO("Configure custom FFmpeg options"))
{
   SetName();
   ShuttleGui S(this, eIsCreatingFromPrefs);
   mFFmpeg = FFmpegFunctions::Load();
   //FFmpegLibsInst()->LoadLibs(NULL,true); //Loaded at startup or from Prefs now
 
   mPresets = std::make_unique<FFmpegPresets>();
   mPresets->GetPresetList(mPresetNames);
 
   if (mFFmpeg)
   {
      FetchFormatList();
      FetchCodecList();
 
      PopulateOrExchange(S);
 
      //Select the format that was selected last time this dialog was closed
      mFormatList->Select(mFormatList->FindString(gPrefs->Read(wxT("/FileFormats/FFmpegFormat"))));
      DoOnFormatList();
 
      //Select the codec that was selected last time this dialog was closed
      auto codec = mFFmpeg->CreateEncoder(gPrefs->Read(wxT("/FileFormats/FFmpegCodec")).ToUTF8());
 
      if (codec != nullptr)
         mCodecList->Select(mCodecList->FindString(wxString::FromUTF8(codec->GetName())));
 
      DoOnCodecList();
   }
 
}

References DoOnCodecList(), DoOnFormatList(), eIsCreatingFromPrefs, FetchCodecList(), FetchFormatList(), gPrefs, FFmpegFunctions::Load(), mCodecList, mFFmpeg, mFormatList, mPresetNames, mPresets, PopulateOrExchange(), audacity::BasicSettings::Read(), S, wxDialogWrapper::SetName(), audacity::ToUTF8(), and wxT().

Here is the call graph for this function:

◆ ~ExportFFmpegOptions()

ExportFFmpegOptions::~ExportFFmpegOptions ( )

Definition at line 473 of file ExportFFmpegOptions.cpp.

474{

475}

Member Function Documentation

◆ DoOnCodecList()

void ExportFFmpegOptions::DoOnCodecList ( )

Definition at line 1284 of file ExportFFmpegOptions.cpp.

{
   wxString *selcdc = nullptr;
   wxString* selcdclong = nullptr;
 
   FindSelectedCodec(&selcdc, &selcdclong);
 
   if (selcdc == nullptr)
   {
      return;
   }
 
   wxString* selfmt = nullptr;
   wxString* selfmtlong = nullptr;
 
   FindSelectedFormat(&selfmt, &selfmtlong);
 
   auto cdc = mFFmpeg->CreateEncoder(selcdc->ToUTF8());
   if (cdc == nullptr)
   {
      //This shouldn't really happen
      /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
      mCodecName->SetLabel(wxString(_("Failed to find the codec")));
      return;
   }
 
   mCodecName->SetLabel(wxString::Format(wxT("[%d] %s"), (int) mFFmpeg->GetAudacityCodecID(cdc->GetId()).value, *selcdclong));
 
   if (selfmt != nullptr)
   {
      auto fmt = mFFmpeg->GuessOutputFormat(selfmt->ToUTF8(), nullptr, nullptr);
      if (fmt == nullptr)
      {
         selfmt = nullptr;
         selfmtlong = nullptr;
      }
   }
 
   int newselfmt = FetchCompatibleFormatList(
      mFFmpeg->GetAudacityCodecID(cdc->GetId()), selfmt);
 
   if (newselfmt >= 0)
      mFormatList->Select(newselfmt);
 
   EnableDisableControls(cdc.get(), selfmt);
   Layout();
   Fit();
   return;
}

References _, EnableDisableControls(), FetchCompatibleFormatList(), FindSelectedCodec(), FindSelectedFormat(), mCodecName, mFFmpeg, mFormatList, and wxT().

Referenced by ExportFFmpegOptions(), OnCodecList(), and OnLoadPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoOnFormatList()

void ExportFFmpegOptions::DoOnFormatList ( )

Definition at line 1234 of file ExportFFmpegOptions.cpp.

{
   wxString *selfmt = NULL;
   wxString *selfmtlong = NULL;
   FindSelectedFormat(&selfmt, &selfmtlong);
   if (selfmt == NULL)
   {
      return;
   }
 
   wxString *selcdc = NULL;
   wxString *selcdclong = NULL;
   FindSelectedCodec(&selcdc, &selcdclong);
 
   auto fmt = mFFmpeg->GuessOutputFormat(selfmt->ToUTF8(),NULL,NULL);
   if (fmt == NULL)
   {
      //This shouldn't really happen
      mFormatName->SetLabel(wxString(_("Failed to guess format")));
      return;
   }
   mFormatName->SetLabel(wxString::Format(wxT("%s"), *selfmtlong));
 
   AudacityAVCodecID selcdcid = AUDACITY_AV_CODEC_ID_NONE;
 
   if (selcdc != nullptr)
   {
      auto cdc = mFFmpeg->CreateEncoder(selcdc->ToUTF8());
 
      if (cdc != nullptr)
      {
         selcdcid = mFFmpeg->GetAudacityCodecID(cdc->GetId());
      }
   }
   int newselcdc =
      FetchCompatibleCodecList(*selfmt, selcdcid);
 
   if (newselcdc >= 0) mCodecList->Select(newselcdc);
 
   std::unique_ptr<AVCodecWrapper> cdc;
 
   if (selcdc != nullptr)
      cdc = mFFmpeg->CreateEncoder(selcdc->ToUTF8());
 
   EnableDisableControls(cdc.get(), selfmt);
   Layout();
   Fit();
   return;
}

References _, AUDACITY_AV_CODEC_ID_NONE, EnableDisableControls(), FetchCompatibleCodecList(), FindSelectedCodec(), FindSelectedFormat(), mCodecList, mFFmpeg, mFormatName, and wxT().

Referenced by ExportFFmpegOptions(), OnFormatList(), and OnLoadPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnableDisableControls()

void ExportFFmpegOptions::EnableDisableControls	(	AVCodecWrapper *	cdc,
		wxString *	selfmt
	)

private

Definition at line 1201 of file ExportFFmpegOptions.cpp.

{
   int handled = -1;
   for (int i = 0; apptable[i].control != 0; i++)
   {
      if (apptable[i].control != handled)
      {
         bool codec = false;
         bool format = false;
         if (apptable[i].codec == AUDACITY_AV_CODEC_ID_NONE)
         {
            codec = true;
         }
         else if (
            cdc != NULL &&
            apptable[i].codec == mFFmpeg->GetAudacityCodecID(cdc->GetId()))
         {
            codec = true;
         }
 
         if (wxString::FromUTF8(apptable[i].format) == wxT("any")) format = true;
         else if (selfmt != NULL &&
            *selfmt == wxString::FromUTF8(apptable[i].format)) format = true;
         if (codec && format)
         {
            handled = apptable[i].control;
            wxWindow *item = FindWindowById(apptable[i].control,this);
            if (item != NULL) item->Enable(apptable[i].enable);
         }
      }
   }
}

References apptable, AUDACITY_AV_CODEC_ID_NONE, ApplicableFor::control, anonymous_namespace{ExportPCM.cpp}::format, AVCodecWrapper::GetId(), mFFmpeg, and wxT().

Referenced by DoOnCodecList(), and DoOnFormatList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchCodecList()

void ExportFFmpegOptions::FetchCodecList ( )

private

Retrieves codec list from libavcodec.

Definition at line 535 of file ExportFFmpegOptions.cpp.

{
   if (!mFFmpeg)
      return;
   // Enumerate all codecs
   std::unique_ptr<AVCodecWrapper> codec;
   for (auto codec : mFFmpeg->GetCodecs())
   {
      // We're only interested in audio and only in encoders
      if (codec->IsAudio() && mFFmpeg->av_codec_is_encoder(codec->GetWrappedValue()))
      {
         // MP2 Codec is broken.  Don't allow it.
         if( codec->GetId() == mFFmpeg->GetAVCodecID(AUDACITY_AV_CODEC_ID_MP2))
            continue;
 
         mCodecNames.push_back(wxString::FromUTF8(codec->GetName()));
         mCodecLongNames.push_back(wxString::Format(wxT("%s - %s"),mCodecNames.back(),wxString::FromUTF8(codec->GetLongName())));
      }
   }
   // Show all codecs
   mShownCodecNames = mCodecNames;
   mShownCodecLongNames = mCodecLongNames;
}

References AUDACITY_AV_CODEC_ID_MP2, mCodecLongNames, mCodecNames, mFFmpeg, mShownCodecLongNames, mShownCodecNames, and wxT().

Referenced by ExportFFmpegOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchCompatibleCodecList()

int ExportFFmpegOptions::FetchCompatibleCodecList	(	const wxChar *	fmt,
		AudacityAVCodecID	id
	)

private

Retrieves a list of codecs compatible to format

Parameters

fmt	Format short name
id	id of the codec selected at the moment

Returns: index of the id in NEW codec list or -1 if it is not in the list

Definition at line 803 of file ExportFFmpegOptions.cpp.

{
   const auto ffmpegId = mFFmpeg->GetAVCodecID(id);
 
   // By default assume that id is not in the list
   int index = -1;
   // By default no codecs are compatible (yet)
   mShownCodecNames.clear();
   mShownCodecLongNames.clear();
   // Clear the listbox
   mCodecList->Clear();
   // Zero - format is not found at all
   int found = 0;
   wxString str(fmt);
   for (int i = 0; CompatibilityList[i].fmt != NULL; i++)
   {
      if (str == CompatibilityList[i].fmt)
      {
         // Format is found in the list
         found = 1;
         if (CompatibilityList[i].codec.value == AUDACITY_AV_CODEC_ID_NONE)
         {
            // Format is found in the list and it is compatible with AUDACITY_AV_CODEC_ID_NONE (means that it is compatible to anything)
            found = 2;
            break;
         }
         // Find the codec, that is claimed to be compatible
         std::unique_ptr<AVCodecWrapper> codec = mFFmpeg->CreateEncoder(mFFmpeg->GetAVCodecID(CompatibilityList[i].codec));
         // If it exists, is audio and has encoder
         if (codec != NULL && codec->IsAudio() && mFFmpeg->av_codec_is_encoder(codec->GetWrappedValue()))
         {
            // If it was selected - remember its NEW index
            if ((ffmpegId >= 0) && codec->GetId() == ffmpegId)
               index = mShownCodecNames.size();
 
            mShownCodecNames.push_back(wxString::FromUTF8(codec->GetName()));
            mShownCodecLongNames.push_back(wxString::Format(wxT("%s - %s"),mShownCodecNames.back(),wxString::FromUTF8(codec->GetLongName())));
         }
      }
   }
   // All codecs are compatible with this format
   if (found == 2)
   {
      std::unique_ptr<AVCodecWrapper> codec;
      for (auto codec : mFFmpeg->GetCodecs())
      {
         if (codec->IsAudio() && mFFmpeg->av_codec_is_encoder(codec->GetWrappedValue()))
         {
            // MP2 is broken.
            if( codec->GetId() == mFFmpeg->GetAVCodecID(AUDACITY_AV_CODEC_ID_MP2) )
               continue;
 
            if (! make_iterator_range( mShownCodecNames )
               .contains( wxString::FromUTF8(codec->GetName()) ) )
            {
               if ((ffmpegId >= 0) && codec->GetId() == ffmpegId)
                  index = mShownCodecNames.size();
 
               mShownCodecNames.push_back(wxString::FromUTF8(codec->GetName()));
               mShownCodecLongNames.push_back(wxString::Format(wxT("%s - %s"),mShownCodecNames.back(),wxString::FromUTF8(codec->GetLongName())));
            }
         }
      }
   }
   // Format is not found - find format in libavformat and add its default audio codec
   // This allows us to provide limited support for NEW formats without modifying the compatibility list
   else if (found == 0)
   {
      wxCharBuffer buf = str.ToUTF8();
      auto format = mFFmpeg->GuessOutputFormat(buf, nullptr, nullptr);
 
      if (format != nullptr)
      {
         auto codec = mFFmpeg->CreateEncoder(format->GetAudioCodec());
 
         if (
            codec != nullptr && codec->IsAudio() && mFFmpeg->av_codec_is_encoder(codec->GetWrappedValue()))
         {
            if ((ffmpegId >= 0) && codec->GetId() == ffmpegId)
               index = mShownCodecNames.size();
 
            mShownCodecNames.push_back(wxString::FromUTF8(codec->GetName()));
            mShownCodecLongNames.push_back(wxString::Format(wxT("%s - %s"),mShownCodecNames.back(),wxString::FromUTF8(codec->GetLongName())));
         }
      }
   }
   // Show NEW codec list
   mCodecList->Append(mShownCodecNames);
 
   return index;
}

References AUDACITY_AV_CODEC_ID_MP2, AUDACITY_AV_CODEC_ID_NONE, CompatibilityEntry::codec, CompatibilityList, CompatibilityEntry::fmt, anonymous_namespace{ExportPCM.cpp}::format, make_iterator_range(), mCodecList, mFFmpeg, mShownCodecLongNames, mShownCodecNames, str, and wxT().

Referenced by DoOnFormatList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchCompatibleFormatList()

int ExportFFmpegOptions::FetchCompatibleFormatList	(	AudacityAVCodecID	id,
		wxString *	selfmt
	)

private

Retrieves a list of formats compatible to codec

Parameters

id	Codec ID
selfmt	format selected at the moment

Returns: index of the selfmt in NEW format list or -1 if it is not in the list

Definition at line 897 of file ExportFFmpegOptions.cpp.

{
   int index = -1;
   mShownFormatNames.clear();
   mShownFormatLongNames.clear();
   mFormatList->Clear();
 
   wxArrayString FromList;
   // Find all formats compatible to this codec in compatibility list
   for (int i = 0; CompatibilityList[i].fmt != NULL; i++)
   {
      if (CompatibilityList[i].codec == id || (CompatibilityList[i].codec.value == AUDACITY_AV_CODEC_ID_NONE) )
      {
         if ((selfmt != NULL) && (*selfmt == CompatibilityList[i].fmt)) index = mShownFormatNames.size();
         FromList.push_back(CompatibilityList[i].fmt);
         mShownFormatNames.push_back(CompatibilityList[i].fmt);
         auto tofmt = mFFmpeg->GuessOutputFormat(
            wxString(CompatibilityList[i].fmt).ToUTF8(), nullptr, nullptr);
 
         if (tofmt != NULL)
         {
            mShownFormatLongNames.push_back(wxString::Format(
               wxT("%s - %s"), CompatibilityList[i].fmt,
               wxString::FromUTF8(tofmt->GetLongName())));
         }
      }
   }
   bool found = false;
   if (selfmt != NULL)
   {
      for (int i = 0; CompatibilityList[i].fmt != NULL; i++)
      {
         if (*selfmt == CompatibilityList[i].fmt)
         {
            found = true;
            break;
         }
      }
   }
   // Format was in the compatibility list
   if (found)
   {
      // Find all formats which have this codec as default and which are not in the list yet and add them too
      for (auto ofmt  : mFFmpeg->GetOutputFormats())
      {
         if (ofmt->GetAudioCodec() == mFFmpeg->GetAVCodecID(id))
         {
            wxString ofmtname = wxString::FromUTF8(ofmt->GetName());
            found = false;
            for (unsigned int i = 0; i < FromList.size(); i++)
            {
               if (ofmtname == FromList[i])
               {
                  found = true;
                  break;
               }
            }
            if (!found)
            {
               if ((selfmt != NULL) &&
                  (*selfmt == wxString::FromUTF8(ofmt->GetName())))
                  index = mShownFormatNames.size();
 
               mShownFormatNames.push_back(wxString::FromUTF8(ofmt->GetName()));
 
               mShownFormatLongNames.push_back(wxString::Format(
                  wxT("%s - %s"), mShownFormatNames.back(),
                  wxString::FromUTF8(ofmt->GetLongName())));
            }
         }
      }
   }
   mFormatList->Append(mShownFormatNames);
   return index;
}

References AUDACITY_AV_CODEC_ID_NONE, CompatibilityList, CompatibilityEntry::fmt, mFFmpeg, mFormatList, mShownFormatLongNames, mShownFormatNames, audacity::ToUTF8(), and wxT().

Referenced by DoOnCodecList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchFormatList()

void ExportFFmpegOptions::FetchFormatList ( )

private

Retrieves format list from libavformat.

Definition at line 513 of file ExportFFmpegOptions.cpp.

{
   if (!mFFmpeg)
      return;
 
   for (auto ofmt : mFFmpeg->GetOutputFormats())
   {
      // Any audio-capable format has default audio codec.
      // If it doesn't, then it doesn't supports any audio codecs
      if (ofmt->GetAudioCodec() != AUDACITY_AV_CODEC_ID_NONE)
      {
         mFormatNames.push_back(wxString::FromUTF8(ofmt->GetName()));
         mFormatLongNames.push_back(wxString::Format(wxT("%s - %s"),mFormatNames.back(),wxString::FromUTF8(ofmt->GetLongName())));
      }
   }
   // Show all formats
   mShownFormatNames = mFormatNames;
   mShownFormatLongNames =  mFormatLongNames;
}

References AUDACITY_AV_CODEC_ID_NONE, mFFmpeg, mFormatLongNames, mFormatNames, mShownFormatLongNames, mShownFormatNames, and wxT().

Referenced by ExportFFmpegOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FetchPresetList()

void ExportFFmpegOptions::FetchPresetList ( )

private

Retrieves list of presets from configuration file.

◆ FindSelectedCodec()

void ExportFFmpegOptions::FindSelectedCodec	(	wxString **	name,
		wxString **	longname
	)

private

Finds the codec currently selected and returns its name and description.

Definition at line 782 of file ExportFFmpegOptions.cpp.

{
   // Get current selection
   wxArrayInt selections;
   int n = mCodecList->GetSelections(selections);
   if (n <= 0) return;
 
   // Get selected codec short name
   wxString selcdc = mCodecList->GetString(selections[0]);
 
   // Find its index
   int nCodec = make_iterator_range( mCodecNames ).index( selcdc );
   if (nCodec == wxNOT_FOUND) return;
 
   // Return short name and description
   if (name != NULL) *name = &mCodecNames[nCodec];
   if (longname != NULL) *longname = &mCodecLongNames[nCodec];
}

References make_iterator_range(), mCodecList, mCodecLongNames, mCodecNames, and name.

Referenced by DoOnCodecList(), DoOnFormatList(), and ReportIfBadCombination().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindSelectedFormat()

void ExportFFmpegOptions::FindSelectedFormat	(	wxString **	name,
		wxString **	longname
	)

private

Finds the format currently selected and returns its name and description.

Definition at line 761 of file ExportFFmpegOptions.cpp.

{
   // Get current selection
   wxArrayInt selections;
   int n = mFormatList->GetSelections(selections);
   if (n <= 0) return;
 
   // Get selected format short name
   wxString selfmt = mFormatList->GetString(selections[0]);
 
   // Find its index
   int nFormat = make_iterator_range( mFormatNames ).index( selfmt );
   if (nFormat == wxNOT_FOUND) return;
 
   // Return short name and description
   if (name != NULL) *name = &mFormatNames[nFormat];
   if (longname != NULL) *longname = &mFormatLongNames[nFormat];
   return;
}

References make_iterator_range(), mFormatList, mFormatLongNames, mFormatNames, and name.

Referenced by DoOnCodecList(), DoOnFormatList(), and ReportIfBadCombination().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnAllCodecs()

void ExportFFmpegOptions::OnAllCodecs ( wxCommandEvent & event )

Definition at line 1125 of file ExportFFmpegOptions.cpp.

{
   mShownCodecNames = mCodecNames;
   mShownCodecLongNames = mCodecLongNames;
   mCodecList->Clear();
   mCodecList->Append(mCodecNames);
}

References mCodecList, mCodecLongNames, mCodecNames, mShownCodecLongNames, and mShownCodecNames.

◆ OnAllFormats()

void ExportFFmpegOptions::OnAllFormats ( wxCommandEvent & event )

Definition at line 1115 of file ExportFFmpegOptions.cpp.

{
   mShownFormatNames = mFormatNames;
   mShownFormatLongNames = mFormatLongNames;
   mFormatList->Clear();
   mFormatList->Append(mFormatNames);
}

References mFormatList, mFormatLongNames, mFormatNames, mShownFormatLongNames, and mShownFormatNames.

◆ OnCodecList()

void ExportFFmpegOptions::OnCodecList ( wxCommandEvent & event )

Definition at line 1343 of file ExportFFmpegOptions.cpp.

{
   DoOnCodecList();
}

References DoOnCodecList().

Here is the call graph for this function:

◆ OnDeletePreset()

void ExportFFmpegOptions::OnDeletePreset ( wxCommandEvent & event )

Definition at line 976 of file ExportFFmpegOptions.cpp.

{
   wxComboBox *preset = dynamic_cast<wxComboBox*>(FindWindowById(FEPresetID,this));
   wxString presetname = preset->GetValue();
   if (presetname.empty())
   {
      AudacityMessageBox( XO("You can't delete a preset without name") );
      return;
   }
 
   auto query = XO("Delete preset '%s'?").Format( presetname );
   int action = AudacityMessageBox(
      query,
      XO("Confirm Deletion"),
      wxYES_NO | wxCENTRE);
   if (action == wxNO) return;
 
   mPresets->DeletePreset(presetname);
   long index = preset->FindString(presetname);
   preset->SetValue(wxEmptyString);
   preset->Delete(index);
   mPresetNames.erase(
      std::find( mPresetNames.begin(), mPresetNames.end(), presetname )
   );
}

References AudacityMessageBox(), mPresetNames, mPresets, preset, and XO().

Here is the call graph for this function:

◆ OnExportPresets()

void ExportFFmpegOptions::OnExportPresets ( wxCommandEvent & event )

Definition at line 1085 of file ExportFFmpegOptions.cpp.

{
   const bool kCheckForOverwrite = true;
   // Bug 1180 save any pending preset before exporting the lot.
   // If saving fails, don't try to export.
   if( !SavePreset(!kCheckForOverwrite) )
      return;
 
   wxArrayString presets;
   mPresets->GetPresetList( presets);
   if( presets.Count() < 1)
   {
      AudacityMessageBox( XO("No presets to export") );
      return;
   }
 
   wxString path;
   FileDialogWrapper dlg(this,
      XO("Select xml file to export presets into"),
      gPrefs->Read(wxT("/FileFormats/FFmpegPresetDir")),
      wxEmptyString,
      FileTypes(),
      wxFD_SAVE|wxFD_OVERWRITE_PROMPT);
   if (dlg.ShowModal() == wxID_CANCEL) return;
   path = dlg.GetPath();
   mPresets->ExportPresets(path);
}

References AudacityMessageBox(), FileTypes(), FileDialog::GetPath(), gPrefs, mPresets, audacity::BasicSettings::Read(), SavePreset(), FileDialog::ShowModal(), wxT(), and XO().

Here is the call graph for this function:

◆ OnFormatList()

void ExportFFmpegOptions::OnFormatList ( wxCommandEvent & event )

Definition at line 1336 of file ExportFFmpegOptions.cpp.

{
   DoOnFormatList();
}

References DoOnFormatList().

Here is the call graph for this function:

◆ OnGetURL()

void ExportFFmpegOptions::OnGetURL ( wxCommandEvent & event )

Definition at line 1372 of file ExportFFmpegOptions.cpp.

{
   HelpSystem::ShowHelp(this, L"Custom_FFmpeg_Export_Options");
}

References HelpSystem::ShowHelp().

Here is the call graph for this function:

◆ OnImportPresets()

void ExportFFmpegOptions::OnImportPresets ( wxCommandEvent & event )

Definition at line 1066 of file ExportFFmpegOptions.cpp.

{
   wxString path;
   FileDialogWrapper dlg(this,
      XO("Select xml file with presets to import"),
      gPrefs->Read(wxT("/FileFormats/FFmpegPresetDir")),
      wxEmptyString,
      FileTypes(),
      wxFD_OPEN);
   if (dlg.ShowModal() == wxID_CANCEL) return;
   path = dlg.GetPath();
   mPresets->ImportPresets(path);
   mPresets->GetPresetList(mPresetNames);
   mPresetCombo->Clear();
   mPresetCombo->Append(mPresetNames);
}

References FileTypes(), FileDialog::GetPath(), gPrefs, mPresetCombo, mPresetNames, mPresets, audacity::BasicSettings::Read(), FileDialog::ShowModal(), wxT(), and XO().

Here is the call graph for this function:

◆ OnLoadPreset()

void ExportFFmpegOptions::OnLoadPreset ( wxCommandEvent & event )

Definition at line 1036 of file ExportFFmpegOptions.cpp.

{
   wxComboBox *preset = dynamic_cast<wxComboBox*>(FindWindowById(FEPresetID,this));
   wxString presetname = preset->GetValue();
 
   mShownFormatNames = mFormatNames;
   mShownFormatLongNames = mFormatLongNames;
   mFormatList->Clear();
   mFormatList->Append(mFormatNames);
 
   mShownCodecNames = mCodecNames;
   mShownCodecLongNames = mCodecLongNames;
   mCodecList->Clear();
   mCodecList->Append(mCodecNames);
 
   mPresets->LoadPreset(this,presetname);
 
   DoOnFormatList();
   DoOnCodecList();
}

References DoOnCodecList(), DoOnFormatList(), mCodecList, mCodecLongNames, mCodecNames, mFormatList, mFormatLongNames, mFormatNames, mPresets, mShownCodecLongNames, mShownCodecNames, mShownFormatLongNames, mShownFormatNames, and preset.

Here is the call graph for this function:

◆ OnOK()

void ExportFFmpegOptions::OnOK ( wxCommandEvent & event )

Definition at line 1351 of file ExportFFmpegOptions.cpp.

{
   if( ReportIfBadCombination() )
      return;
 
   int selcdc = mCodecList->GetSelection();
   int selfmt = mFormatList->GetSelection();
   if (selcdc > -1) gPrefs->Write(wxT("/FileFormats/FFmpegCodec"),mCodecList->GetString(selcdc));
   if (selfmt > -1) gPrefs->Write(wxT("/FileFormats/FFmpegFormat"),mFormatList->GetString(selfmt));
   gPrefs->Flush();
 
   ShuttleGui S(this, eIsSavingToPrefs);
   PopulateOrExchange(S);
 
   gPrefs->Flush();
 
   EndModal(wxID_OK);
 
   return;
}

References eIsSavingToPrefs, audacity::BasicSettings::Flush(), gPrefs, mCodecList, mFormatList, PopulateOrExchange(), ReportIfBadCombination(), S, audacity::BasicSettings::Write(), and wxT().

Here is the call graph for this function:

◆ OnSavePreset()

void ExportFFmpegOptions::OnSavePreset ( wxCommandEvent & event )

Definition at line 1004 of file ExportFFmpegOptions.cpp.

{  const bool kCheckForOverwrite = true;
   SavePreset(kCheckForOverwrite);
}

References SavePreset().

Here is the call graph for this function:

◆ PopulateOrExchange()

void ExportFFmpegOptions::PopulateOrExchange ( ShuttleGui & S )

Definition at line 561 of file ExportFFmpegOptions.cpp.

{
   IntSetting PredictionOrderSetting{ L"/FileFormats/FFmpegPredOrderMethod",
      4 };  // defaults to Full search
 
   S.StartVerticalLay(1);
   S.StartMultiColumn(1, wxEXPAND);
   {
      S.SetStretchyRow(3);
      S.StartMultiColumn(7, wxEXPAND);
      {
         S.SetStretchyCol(1);
         mPresetCombo = S.Id(FEPresetID).AddCombo(XXO("Preset:"), gPrefs->Read(wxT("/FileFormats/FFmpegPreset"),wxEmptyString), mPresetNames);
         S.Id(FELoadPresetID).AddButton(XXO("Load Preset"));
         S.Id(FESavePresetID).AddButton(XXO("Save Preset"));
         S.Id(FEDeletePresetID).AddButton(XXO("Delete Preset"));
         S.Id(FEImportPresetsID).AddButton(XXO("Import Presets"));
         S.Id(FEExportPresetsID).AddButton(XXO("Export Presets"));
      }
      S.EndMultiColumn();
      S.StartMultiColumn(4, wxALIGN_LEFT);
      {
         S.SetStretchyCol(1);
         S.SetStretchyCol(3);
         S.Id(FEFormatLabelID).AddFixedText(XO("Format:"));
         mFormatName = S.Id(FEFormatNameID).AddVariableText( {} );
         /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
         S.Id(FECodecLabelID).AddFixedText(XO("Codec:"));
         mCodecName = S.Id(FECodecNameID).AddVariableText( {} );
      }
      S.EndMultiColumn();
      S.AddVariableText(XO(
"Not all formats and codecs are compatible. Nor are all option combinations compatible with all codecs."),
         false);
      S.StartMultiColumn(2, wxEXPAND);
      {
         S.StartMultiColumn(2, wxEXPAND);
         {
            S.SetStretchyRow(1);
            S.Id(FEAllFormatsID).AddButton(XXO("Show All Formats"));
            S.Id(FEAllCodecsID).AddButton(XXO("Show All Codecs"));
            mFormatList = S.Id(FEFormatID).Name(XO("Formats")).
               AddListBox(mFormatNames);
            mFormatList->DeselectAll();
            mCodecList = S.Id(FECodecID).Name(XO("Codecs")).
               AddListBox(mCodecNames);
            mCodecList->DeselectAll();
#if wxUSE_ACCESSIBILITY
            // so that names can be set on standard controls
            safenew WindowAccessible(mFormatList);
            safenew WindowAccessible(mCodecList);
#endif
         }
         S.EndMultiColumn();
         S.StartVerticalLay();
         {
            //S.StartScroller( );
            S.SetBorder( 3 );
            S.StartStatic(XO("General Options"), 0);
            {
               S.StartMultiColumn(8, wxEXPAND);
               {
                  S.Id(FELanguageID)
                     .ToolTip(XO("ISO 639 3-letter language code\nOptional\nempty - automatic"))
                     .TieTextBox(XXO("Language:"), {wxT("/FileFormats/FFmpegLanguage"), wxEmptyString}, 9);
 
                  S.AddSpace( 20,0 );
                  S.AddVariableText(XO("Bit Reservoir"));
                  S.Id(FEBitReservoirID).TieCheckBox( {}, {wxT("/FileFormats/FFmpegBitReservoir"), true});
 
                  S.AddSpace( 20,0 );
                  S.AddVariableText(XO("VBL"));
                  S.Id(FEVariableBlockLenID).TieCheckBox( {}, {wxT("/FileFormats/FFmpegVariableBlockLen"), true});
               }
               S.EndMultiColumn();
               S.StartMultiColumn(4, wxALIGN_LEFT);
               {
                  S.Id(FETagID)
                     /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
                     .ToolTip(XO("Codec tag (FOURCC)\nOptional\nempty - automatic"))
                     .TieTextBox(XXO("Tag:"), {wxT("/FileFormats/FFmpegTag"), wxEmptyString}, 4);
 
                  S.Id(FEBitrateID)
                     .ToolTip(XO("Bit Rate (bits/second) - influences the resulting file size and quality\nSome codecs may only accept specific values (128k, 192k, 256k etc)\n0 - automatic\nRecommended - 192000"))
                     .TieSpinCtrl(XXO("Bit Rate:"), {wxT("/FileFormats/FFmpegBitRate"), 0}, 1000000, 0);
 
                  S.Id(FEQualityID)
                     .ToolTip(XO("Overall quality, used differently by different codecs\nRequired for vorbis\n0 - automatic\n-1 - off (use bitrate instead)"))
                     .TieSpinCtrl(XXO("Quality:"), {wxT("/FileFormats/FFmpegQuality"), 0}, 500, -1);
 
                  S.Id(FESampleRateID)
                     .ToolTip(XO("Sample rate (Hz)\n0 - don't change sample rate"))
                     .TieSpinCtrl(XXO("Sample Rate:"), {wxT("/FileFormats/FFmpegSampleRate"), 0}, 200000, 0);
 
                  S.Id(FECutoffID)
                     .ToolTip(XO("Audio cutoff bandwidth (Hz)\nOptional\n0 - automatic"))
                     .TieSpinCtrl(XXO("Cutoff:"), {wxT("/FileFormats/FFmpegCutOff"), 0}, 10000000, 0);
 
                  // PRL:  As commented elsewhere, this preference does nothing
                  S.Id(FEProfileID)
                     .ToolTip(XO("AAC Profile\nLow Complexity - default\nMost players won't play anything other than LC"))
                     .MinSize( { 100, -1 } )
                     .TieChoice(XXO("Profile:"), AACProfiles);
               }
               S.EndMultiColumn();
            }
            S.EndStatic();
            S.StartStatic(XO("FLAC options"),0);
            {
               S.StartMultiColumn(4, wxALIGN_LEFT);
               {
                  S
                     .ToolTip(XO("Compression level\nRequired for FLAC\n-1 - automatic\nmin - 0 (fast encoding, large output file)\nmax - 10 (slow encoding, small output file)"))
                     .Id(FECompLevelID).TieSpinCtrl(XXO("Compression:"), {wxT("/FileFormats/FFmpegCompLevel"), 0}, 10, -1);
 
                  S.Id(FEFrameSizeID)
                     .ToolTip(XO("Frame size\nOptional\n0 - default\nmin - 16\nmax - 65535"))
                     .TieSpinCtrl(XXO("Frame:"), {wxT("/FileFormats/FFmpegFrameSize"), 0}, 65535, 0);
 
                  S.Id(FELPCCoeffsID)
                     .ToolTip(XO("LPC coefficients precision\nOptional\n0 - default\nmin - 1\nmax - 15"))
                     .TieSpinCtrl(XXO("LPC"), {wxT("/FileFormats/FFmpegLPCCoefPrec"), 0}, 15, 0);
 
                  S.Id(FEPredOrderID)
                     .ToolTip(XO("Prediction Order Method\nEstimate - fastest, lower compression\nLog search - slowest, best compression\nFull search - default"))
                     .MinSize( { 100, -1 } )
                     .TieNumberAsChoice(
                        XXO("PdO Method:"),
                        PredictionOrderSetting,
                        PredictionOrderMethodNames
                     );
 
                  S.Id(FEMinPredID)
                     .ToolTip(XO("Minimal prediction order\nOptional\n-1 - default\nmin - 0\nmax - 32 (with LPC) or 4 (without LPC)"))
                     .TieSpinCtrl(XXO("Min. PdO"), {wxT("/FileFormats/FFmpegMinPredOrder"), -1}, 32, -1);
 
                  S.Id(FEMaxPredID)
                     .ToolTip(XO("Maximal prediction order\nOptional\n-1 - default\nmin - 0\nmax - 32 (with LPC) or 4 (without LPC)"))
                     .TieSpinCtrl(XXO("Max. PdO"), {wxT("/FileFormats/FFmpegMaxPredOrder"), -1}, 32, -1);
 
                  S.Id(FEMinPartOrderID)
                     .ToolTip(XO("Minimal partition order\nOptional\n-1 - default\nmin - 0\nmax - 8"))
                     .TieSpinCtrl(XXO("Min. PtO"), {wxT("/FileFormats/FFmpegMinPartOrder"), -1}, 8, -1);
 
                  S.Id(FEMaxPartOrderID)
                     .ToolTip(XO("Maximal partition order\nOptional\n-1 - default\nmin - 0\nmax - 8"))
                     .TieSpinCtrl(XXO("Max. PtO"), {wxT("/FileFormats/FFmpegMaxPartOrder"), -1}, 8, -1);
 
                  /* i18n-hint:  Abbreviates "Linear Predictive Coding",
                     but this text needs to be kept very short */
                  S.AddVariableText(XO("Use LPC"));
                  // PRL:  This preference is not used anywhere!
                  S.Id(FEUseLPCID).TieCheckBox( {}, {wxT("/FileFormats/FFmpegUseLPC"), true});
               }
               S.EndMultiColumn();
            }
            S.EndStatic();
            S.StartStatic(XO("MPEG container options"),0);
            {
               S.StartMultiColumn(4, wxALIGN_LEFT);
               {
                  S.Id(FEMuxRateID)
                     .ToolTip(XO("Maximum bit rate of the multiplexed stream\nOptional\n0 - default"))
                     /* i18n-hint: 'mux' is short for multiplexor, a device that selects between several inputs
                       'Mux Rate' is a parameter that has some bearing on compression ratio for MPEG
                       it has a hard to predict effect on the degree of compression */
                     .TieSpinCtrl(XXO("Mux Rate:"), {wxT("/FileFormats/FFmpegMuxRate"), 0}, 10000000, 0);
 
                  S.Id(FEPacketSizeID)
                     /* i18n-hint: 'Packet Size' is a parameter that has some bearing on compression ratio for MPEG
                       compression.  It measures how big a chunk of audio is compressed in one piece. */
                     .ToolTip(XO("Packet size\nOptional\n0 - default"))
                     /* i18n-hint: 'Packet Size' is a parameter that has some bearing on compression ratio for MPEG
                       compression.  It measures how big a chunk of audio is compressed in one piece. */
                     .TieSpinCtrl(XXO("Packet Size:"), {wxT("/FileFormats/FFmpegPacketSize"), 0}, 10000000, 0);
               }
               S.EndMultiColumn();
            }
            S.EndStatic();
            //S.EndScroller();
            S.SetBorder( 5 );
            S.AddStandardButtons(eOkButton | eCancelButton | eHelpButton );
         }
         S.EndVerticalLay();
      }
      S.EndMultiColumn();
   }
   S.EndMultiColumn();
   S.EndVerticalLay();
 
   Layout();
   Fit();
   SetMinSize(GetSize());
   Center();
 
   return;
}

References AACProfiles, eCancelButton, eHelpButton, eOkButton, gPrefs, mCodecList, mCodecName, mCodecNames, mFormatList, mFormatName, mFormatNames, mPresetCombo, mPresetNames, anonymous_namespace{ExportFFmpegOptions.cpp}::PredictionOrderMethodNames, audacity::BasicSettings::Read(), S, safenew, wxT(), XO(), and XXO().

Referenced by ExportFFmpegOptions(), and OnOK().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReportIfBadCombination()

bool ExportFFmpegOptions::ReportIfBadCombination ( )

private

ReportIfBadCombination will trap bad combinations of format and codec and report using a message box. We may later extend it to catch bad parameters too.

Returns: true iff a bad combination was reported At the moment we don't trap unrecognised format or codec. (We do not expect them to happen ever).

Definition at line 1140 of file ExportFFmpegOptions.cpp.

{
   wxString *selcdc = nullptr;
   wxString* selcdclong = nullptr;
 
   FindSelectedCodec(&selcdc, &selcdclong);
 
   if (selcdc == nullptr)
      return false; // unrecognised codec. Treated as OK
 
   auto cdc = mFFmpeg->CreateEncoder(selcdc->ToUTF8());
 
   if (cdc == nullptr)
      return false; // unrecognised codec. Treated as OK
 
   wxString* selfmt = nullptr;
   wxString* selfmtlong = nullptr;
 
   FindSelectedFormat(&selfmt, &selfmtlong);
 
   if (selfmt == nullptr)
      return false; // unrecognised format; Treated as OK
 
   // This is intended to test for illegal combinations.
   // However, the list updating now seems to be working correctly
   // making it impossible to select illegal combinations
   bool bFound = false;
   for (int i = 0; CompatibilityList[i].fmt != NULL; i++)
   {
      if (*selfmt == CompatibilityList[i].fmt)
      {
         if (CompatibilityList[i].codec == mFFmpeg->GetAudacityCodecID(cdc->GetId()) || (CompatibilityList[i].codec == AUDACITY_AV_CODEC_ID_NONE) ){
            bFound = true;
            break;
         }
      }
   }
 
   // We can put extra code in here, to disallow combinations
   // We could also test for illegal parameters, and deliver
   // custom error messages in that case.
   // The below would make AAC codec disallowed.
   //if( cdc->id == AUDACITY_AV_CODEC_ID_AAC)
   //   bFound = false;
 
   // Valid combination was found, so no reporting.
   if( bFound )
      return false;
 
   AudacityMessageBox(
      /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
      XO("Format %s is not compatible with codec %s.")
         .Format( *selfmt, *selcdc ),
      /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
      XO("Incompatible format and codec"));
 
   return true;
}

References AUDACITY_AV_CODEC_ID_NONE, AudacityMessageBox(), CompatibilityEntry::codec, CompatibilityList, FindSelectedCodec(), FindSelectedFormat(), CompatibilityEntry::fmt, mFFmpeg, and XO().

Referenced by OnOK().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SavePreset()

bool ExportFFmpegOptions::SavePreset ( bool bCheckForOverwrite )

Definition at line 1010 of file ExportFFmpegOptions.cpp.

{
   wxComboBox *preset = dynamic_cast<wxComboBox*>(FindWindowById(FEPresetID,this));
   wxString name = preset->GetValue();
   if (name.empty())
   {
      AudacityMessageBox( XO("You can't save a preset without a name") );
      return false;
   }
   if( bCheckForOverwrite && !mPresets->OverwriteIsOk(name))
      return false;
   if( !mPresets->SavePreset(this,name) )
      return false;
   int index = mPresetNames.Index(name,false);
   if (index == -1)
   {
      mPresetNames.push_back(name);
      mPresetCombo->Clear();
      mPresetCombo->Append(mPresetNames);
      mPresetCombo->Select(mPresetNames.Index(name,false));
   }
   return true;
}

References AudacityMessageBox(), mPresetCombo, mPresetNames, mPresets, name, preset, and XO().

Referenced by OnExportPresets(), and OnSavePreset().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ apptable

ApplicableFor ExportFFmpegOptions::apptable

static

Some controls (parameters they represent) are only applicable to a number of codecs and/or formats. Syntax: first, enable a control for each applicable format-codec combination then disable it for anything else "any" - any format AUDACITY_AV_CODEC_ID_NONE - any codec This list must end with {FALSE,FFmpegExportCtrlID(0),AUDACITY_AV_CODEC_ID_NONE,NULL}

Definition at line 100 of file ExportFFmpegOptions.h.

Referenced by EnableDisableControls().

◆ CompatibilityList

CompatibilityEntry ExportFFmpegOptions::CompatibilityList

static

Format-codec compatibility list Must end with NULL entry

Definition at line 97 of file ExportFFmpegOptions.h.

Referenced by FetchCompatibleCodecList(), FetchCompatibleFormatList(), and ReportIfBadCombination().

◆ fmts

ExposedFormat ExportFFmpegOptions::fmts

static

Initial value:

=
{
   {FMT_M4A,   wxT("M4A"),    wxT("m4a"),  wxT("ipod"), 48,  AV_CANMETA,              true,  XO("M4A (AAC) Files (FFmpeg)"),         AUDACITY_AV_CODEC_ID_AAC,    true},
   {FMT_AC3,   wxT("AC3"),    wxT("ac3"),  wxT("ac3"),  7,   AV_VERSION_INT(0,0,0),   false, XO("AC3 Files (FFmpeg)"),               AUDACITY_AV_CODEC_ID_AC3,    true},
   {FMT_AMRNB, wxT("AMRNB"),  wxT("amr"),  wxT("amr"),  1,   AV_VERSION_INT(0,0,0),   false, XO("AMR (narrow band) Files (FFmpeg)"), AUDACITY_AV_CODEC_ID_AMR_NB, true},
 
 
 
   {FMT_WMA2,  wxT("WMA"),    wxT("wma"),  wxT("asf"),  2,   AV_VERSION_INT(52,53,0), false, XO("WMA (version 2) Files (FFmpeg)"),   AUDACITY_AV_CODEC_ID_WMAV2,  true},
   {FMT_OTHER, wxT("FFMPEG"), wxT(""),     wxT(""),     255, AV_CANMETA,              true,  XO("Custom FFmpeg Export"),             AUDACITY_AV_CODEC_ID_NONE,   true}
}

List of export types.

Definition at line 98 of file ExportFFmpegOptions.h.

Referenced by AdjustFormatIndex(), ExportFFmpeg::ExportFFmpeg(), FFmpegExporter::Init(), FFmpegExporter::InitCodecs(), and FFmpegExportProcessor::Initialize().

◆ iAACSampleRates

const int ExportFFmpegOptions::iAACSampleRates[]

static

Definition at line 99 of file ExportFFmpegOptions.h.

◆ mBitRateFromChoice

int ExportFFmpegOptions::mBitRateFromChoice

private

Definition at line 121 of file ExportFFmpegOptions.h.

◆ mCodecList

wxListBox* ExportFFmpegOptions::mCodecList

private

Definition at line 114 of file ExportFFmpegOptions.h.

Referenced by DoOnFormatList(), ExportFFmpegOptions(), FetchCompatibleCodecList(), FindSelectedCodec(), OnAllCodecs(), OnLoadPreset(), OnOK(), and PopulateOrExchange().

◆ mCodecLongNames

wxArrayString ExportFFmpegOptions::mCodecLongNames

private

Definition at line 111 of file ExportFFmpegOptions.h.

Referenced by FetchCodecList(), FindSelectedCodec(), OnAllCodecs(), and OnLoadPreset().

◆ mCodecName

wxStaticText* ExportFFmpegOptions::mCodecName

private

Definition at line 117 of file ExportFFmpegOptions.h.

Referenced by DoOnCodecList(), and PopulateOrExchange().

◆ mCodecNames

wxArrayStringEx ExportFFmpegOptions::mCodecNames

private

Definition at line 110 of file ExportFFmpegOptions.h.

Referenced by FetchCodecList(), FindSelectedCodec(), OnAllCodecs(), OnLoadPreset(), and PopulateOrExchange().

◆ mFFmpeg

std::shared_ptr<FFmpegFunctions> ExportFFmpegOptions::mFFmpeg

private

Definition at line 128 of file ExportFFmpegOptions.h.

Referenced by DoOnCodecList(), DoOnFormatList(), EnableDisableControls(), ExportFFmpegOptions(), FetchCodecList(), FetchCompatibleCodecList(), FetchCompatibleFormatList(), FetchFormatList(), and ReportIfBadCombination().

◆ mFormatList

wxListBox* ExportFFmpegOptions::mFormatList

private

Definition at line 113 of file ExportFFmpegOptions.h.

Referenced by DoOnCodecList(), ExportFFmpegOptions(), FetchCompatibleFormatList(), FindSelectedFormat(), OnAllFormats(), OnLoadPreset(), OnOK(), and PopulateOrExchange().

◆ mFormatLongNames

wxArrayString ExportFFmpegOptions::mFormatLongNames

private

Definition at line 109 of file ExportFFmpegOptions.h.

Referenced by FetchFormatList(), FindSelectedFormat(), OnAllFormats(), and OnLoadPreset().

◆ mFormatName

wxStaticText* ExportFFmpegOptions::mFormatName

private

Definition at line 116 of file ExportFFmpegOptions.h.

Referenced by DoOnFormatList(), and PopulateOrExchange().

◆ mFormatNames

wxArrayStringEx ExportFFmpegOptions::mFormatNames

private

Definition at line 108 of file ExportFFmpegOptions.h.

Referenced by FetchFormatList(), FindSelectedFormat(), OnAllFormats(), OnLoadPreset(), and PopulateOrExchange().

◆ mPresetCombo

wxComboBox* ExportFFmpegOptions::mPresetCombo

private

Definition at line 119 of file ExportFFmpegOptions.h.

Referenced by OnImportPresets(), PopulateOrExchange(), and SavePreset().

◆ mPresetNames

wxArrayStringEx ExportFFmpegOptions::mPresetNames

private

Definition at line 126 of file ExportFFmpegOptions.h.

Referenced by ExportFFmpegOptions(), OnDeletePreset(), OnImportPresets(), PopulateOrExchange(), and SavePreset().

◆ mPresets

std::unique_ptr<FFmpegPresets> ExportFFmpegOptions::mPresets

private

Definition at line 124 of file ExportFFmpegOptions.h.

Referenced by ExportFFmpegOptions(), OnDeletePreset(), OnExportPresets(), OnImportPresets(), OnLoadPreset(), and SavePreset().

◆ mSampleRateFromChoice

int ExportFFmpegOptions::mSampleRateFromChoice

private

Definition at line 122 of file ExportFFmpegOptions.h.

◆ mShownCodecLongNames

wxArrayString ExportFFmpegOptions::mShownCodecLongNames

private

Definition at line 107 of file ExportFFmpegOptions.h.

Referenced by FetchCodecList(), FetchCompatibleCodecList(), OnAllCodecs(), and OnLoadPreset().

◆ mShownCodecNames

wxArrayString ExportFFmpegOptions::mShownCodecNames

private

Definition at line 106 of file ExportFFmpegOptions.h.

Referenced by FetchCodecList(), FetchCompatibleCodecList(), OnAllCodecs(), and OnLoadPreset().

◆ mShownFormatLongNames

wxArrayString ExportFFmpegOptions::mShownFormatLongNames

private

Definition at line 105 of file ExportFFmpegOptions.h.

Referenced by FetchCompatibleFormatList(), FetchFormatList(), OnAllFormats(), and OnLoadPreset().

◆ mShownFormatNames

wxArrayString ExportFFmpegOptions::mShownFormatNames

private

Definition at line 104 of file ExportFFmpegOptions.h.

Referenced by FetchCompatibleFormatList(), FetchFormatList(), OnAllFormats(), and OnLoadPreset().

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

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ExportFFmpegOptions()

◆ ~ExportFFmpegOptions()

Member Function Documentation

◆ DoOnCodecList()

◆ DoOnFormatList()

◆ EnableDisableControls()

◆ FetchCodecList()

◆ FetchCompatibleCodecList()

◆ FetchCompatibleFormatList()

◆ FetchFormatList()

◆ FetchPresetList()

◆ FindSelectedCodec()

◆ FindSelectedFormat()

◆ OnAllCodecs()

◆ OnAllFormats()

◆ OnCodecList()

◆ OnDeletePreset()

◆ OnExportPresets()

◆ OnFormatList()

◆ OnGetURL()

◆ OnImportPresets()

◆ OnLoadPreset()

◆ OnOK()

◆ OnSavePreset()

◆ PopulateOrExchange()

◆ ReportIfBadCombination()

◆ SavePreset()

Member Data Documentation

◆ apptable

◆ CompatibilityList

◆ fmts

◆ iAACSampleRates

◆ mBitRateFromChoice

◆ mCodecList

◆ mCodecLongNames

◆ mCodecName

◆ mCodecNames

◆ mFFmpeg

◆ mFormatList

◆ mFormatLongNames

◆ mFormatName

◆ mFormatNames

◆ mPresetCombo

◆ mPresetNames

◆ mPresets

◆ mSampleRateFromChoice

◆ mShownCodecLongNames

◆ mShownCodecNames

◆ mShownFormatLongNames

◆ mShownFormatNames