#include <AudioUnitWrapper.h>

Collaboration diagram for AudioUnitWrapper::ParameterInfo:

Public Member Functions
	ParameterInfo (AudioUnit mUnit, AudioUnitParameterID parmID)
	Make a structure holding a key for the config file and a value. More...

Static Public Member Functions
static std::optional< AudioUnitParameterID >	ParseKey (const wxString &key)
	Recover the parameter ID from the key, if well formed. More...

Public Attributes
std::optional< wxString >	mName

AudioUnitUtils::ParameterInfo	mInfo {}

Static Private Attributes
static constexpr char	idBeg = wxT('<')

static constexpr char	idSep = wxT(',')

static constexpr char	idEnd = wxT('>')

Detailed Description

Definition at line 195 of file AudioUnitWrapper.h.

Constructor & Destructor Documentation

◆ ParameterInfo()

AudioUnitWrapper::ParameterInfo::ParameterInfo	(	AudioUnit	mUnit,
		AudioUnitParameterID	parmID
	)

Make a structure holding a key for the config file and a value.

Definition at line 68 of file AudioUnitWrapper.cpp.

{
   UInt32 dataSize;
 
   mInfo = {};
   // Note non-default element parameter, parmID
   if (AudioUnitUtils::GetFixedSizeProperty(mUnit,
      kAudioUnitProperty_ParameterInfo, mInfo,
      kAudioUnitScope_Global, parmID))
      return;
 
   wxString &name = mName.emplace();
   if (mInfo.flags & kAudioUnitParameterFlag_HasCFNameString)
      name = wxCFStringRef::AsString(mInfo.cfNameString);
   else
      name = wxString(mInfo.name);
 
#if defined(USE_EXTENDED_NAMES)
   // Parameter name may or may not be present.  The modified name will be:
   //
   //    <[ParameterName,]parmID>
   //
   // (where the [ ] meta-characters denote optionality)
   // (And any of the characters < , > in ParameterName are replaced with _)
   if (!name.empty()) {
      name.Replace(idBeg, wxT('_'));
      name.Replace(idSep, wxT('_'));
      name.Replace(idEnd, wxT('_'));
      name.Append(idSep);
   }
   name = wxString::Format(wxT("%c%s%x%c"), idBeg, name, parmID, idEnd);
 
   // If the parameter has a clumpID, then the final modified name will be:
   //
   //    <[clumpName,]clumpId><[ParameterName,]parmID>
   //
   // (And any of the characters < , > in clumpName are replaced with _)
   if (mInfo.flags & kAudioUnitParameterFlag_HasClump) {
      wxString clumpName;
      AudioUnitUtils::ParameterNameInfo clumpInfo{
         mInfo.clumpID, kAudioUnitParameterName_Full
      };
 
      if (!AudioUnitUtils::GetFixedSizeProperty(mUnit,
         kAudioUnitProperty_ParameterClumpName, clumpInfo)) {
         clumpName =  wxCFStringRef::AsString(clumpInfo.outName);
         clumpName.Replace(idBeg, wxT('_'));
         clumpName.Replace(idSep, wxT('_'));
         clumpName.Replace(idEnd, wxT('_'));
         clumpName.Append(idSep);
      }
      name = wxString::Format(wxT("%c%s%x%c%s"),
         idBeg, clumpName, mInfo.clumpID, idEnd, name);
   }
#endif
}

References TranslatableString::empty(), AudioUnitUtils::GetFixedSizeProperty(), idBeg, idEnd, idSep, mInfo, mName, AudioUnitWrapper::mUnit, name, and wxT().

Here is the call graph for this function:

Member Function Documentation

◆ ParseKey()

std::optional< AudioUnitParameterID > AudioUnitWrapper::ParameterInfo::ParseKey ( const wxString & key )

static

Recover the parameter ID from the key, if well formed.

Definition at line 127 of file AudioUnitWrapper.cpp.

{
   // This is not a complete validation of the format of the key
   // Scan left for , or <
   if (const auto rend = key.rend(), riter = std::find_if(key.rbegin(), rend,
      [](wxChar c) { return c == idBeg || c == idSep; })
      ; riter != rend
   ) {
      // Scan right for >
      if (const auto end = key.end(), left = riter.base(), // one right of riter
         right = std::find(left, end, idEnd)
         ; left != right && right != end
      ){
         // Interpret character range as hex
         if (long value{}
             ; wxString{left, right}.ToLong(&value, 16))
            return value;
      }
   }
   return {};
}