cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/AU/AUPublic/AUBase/ComponentBase.cpp

@@ -0,0 +1,370 @@
+/*
+     File: ComponentBase.cpp 
+ Abstract:  ComponentBase.h  
+  Version: 1.01 
+  
+ Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple 
+ Inc. ("Apple") in consideration of your agreement to the following 
+ terms, and your use, installation, modification or redistribution of 
+ this Apple software constitutes acceptance of these terms.  If you do 
+ not agree with these terms, please do not use, install, modify or 
+ redistribute this Apple software. 
+  
+ In consideration of your agreement to abide by the following terms, and 
+ subject to these terms, Apple grants you a personal, non-exclusive 
+ license, under Apple's copyrights in this original Apple software (the 
+ "Apple Software"), to use, reproduce, modify and redistribute the Apple 
+ Software, with or without modifications, in source and/or binary forms; 
+ provided that if you redistribute the Apple Software in its entirety and 
+ without modifications, you must retain this notice and the following 
+ text and disclaimers in all such redistributions of the Apple Software. 
+ Neither the name, trademarks, service marks or logos of Apple Inc. may 
+ be used to endorse or promote products derived from the Apple Software 
+ without specific prior written permission from Apple.  Except as 
+ expressly stated in this notice, no other rights or licenses, express or 
+ implied, are granted by Apple herein, including but not limited to any 
+ patent rights that may be infringed by your derivative works or by other 
+ works in which the Apple Software may be incorporated. 
+  
+ The Apple Software is provided by Apple on an "AS IS" basis.  APPLE 
+ MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION 
+ THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND 
+ OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS. 
+  
+ IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL 
+ OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, 
+ MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED 
+ AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), 
+ STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE 
+ POSSIBILITY OF SUCH DAMAGE. 
+  
+ Copyright (C) 2012 Apple Inc. All Rights Reserved. 
+  
+*/
+#include "ComponentBase.h"
+#include "CAXException.h"
+
+#if TARGET_OS_MAC
+pthread_mutex_t ComponentInitLocker::sComponentOpenMutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_once_t ComponentInitLocker::sOnce = PTHREAD_ONCE_INIT;
+
+void ComponentInitLocker::InitComponentInitLocker()
+{
+	// have to do this because OS X lacks PTHREAD_MUTEX_RECURSIVE_INITIALIZER_NP
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&sComponentOpenMutex, &attr);
+	pthread_mutexattr_destroy(&attr);
+}
+
+#elif TARGET_OS_WIN32
+CAGuard	ComponentInitLocker::sComponentOpenGuard("sComponentOpenGuard");
+#endif
+
+ComponentBase::EInstanceType ComponentBase::sNewInstanceType;
+
+static OSStatus CB_GetComponentDescription (const AudioComponentInstance inInstance, AudioComponentDescription * outDesc);
+#if !CA_USE_AUDIO_PLUGIN_ONLY && !TARGET_OS_WIN32
+	static OSStatus CMgr_GetComponentDescription (const AudioComponentInstance inInstance, AudioComponentDescription * outDesc);
+#endif
+
+ComponentBase::ComponentBase(AudioComponentInstance inInstance) 
+	: mComponentInstance(inInstance), 
+	  mInstanceType(sNewInstanceType) 
+{ 
+	GetComponentDescription(); 
+}
+
+ComponentBase::~ComponentBase()
+{
+}
+
+void			ComponentBase::PostConstructor()
+{
+}
+
+void			ComponentBase::PreDestructor()
+{
+}
+
+#define ACPI	((AudioComponentPlugInInstance *)self)
+#define ACImp	((ComponentBase *)&ACPI->mInstanceStorage)
+
+OSStatus ComponentBase::AP_Open(void *self, AudioUnit compInstance)
+{
+	OSStatus result = noErr;
+	try {
+		ComponentInitLocker lock;
+		
+		ComponentBase::sNewInstanceType = ComponentBase::kAudioComponentInstance;
+		ComponentBase *cb = (ComponentBase *)(*ACPI->mConstruct)(&ACPI->mInstanceStorage, compInstance);
+		cb->PostConstructor();	// allows base class to do additional initialization
+		// once the derived class is fully constructed
+		result = noErr;
+	}
+	COMPONENT_CATCH
+	if (result)
+		delete ACPI;
+	return result;
+}
+
+OSStatus ComponentBase::AP_Close(void *self)
+{
+	OSStatus result = noErr;
+	try {
+		if (ACImp) {
+			ACImp->PreDestructor();
+			(*ACPI->mDestruct)(&ACPI->mInstanceStorage);
+			free(self);
+		}
+	}
+	COMPONENT_CATCH
+	return result;
+}
+
+#if !CA_USE_AUDIO_PLUGIN_ONLY
+OSStatus		ComponentBase::Version()
+{
+	return 0x00000001;
+}
+
+OSStatus		ComponentBase::ComponentEntryDispatch(ComponentParameters *p, ComponentBase *This)
+{
+	if (This == NULL) return kAudio_ParamError;
+
+	OSStatus result = noErr;
+	
+	switch (p->what) {
+	case kComponentCloseSelect:
+		This->PreDestructor();
+		delete This;
+		break;
+	
+	case kComponentVersionSelect:
+		result = This->Version();
+		break;
+
+	case kComponentCanDoSelect:
+		switch (GetSelectorForCanDo(p)) {
+		case kComponentOpenSelect:
+		case kComponentCloseSelect:
+		case kComponentVersionSelect:
+		case kComponentCanDoSelect:
+			return 1;
+		default:
+			return 0;
+		}
+		
+	default:
+		result = badComponentSelector;
+		break;
+	}
+	return result;
+}
+
+SInt16		ComponentBase::GetSelectorForCanDo(ComponentParameters *params)
+{
+	if (params->what != kComponentCanDoSelect) return 0;
+	
+	#if TARGET_CPU_X86
+		SInt16 sel = params->params[0];
+	#elif TARGET_CPU_X86_64
+		SInt16 sel = params->params[1];
+	#elif TARGET_CPU_PPC
+		SInt16 sel = (params->params[0] >> 16);
+	#else
+		SInt16 sel = params->params[0];
+	#endif
+	
+	return sel;
+/*		
+		printf ("flags:%d, paramSize: %d, what: %d\n\t", params->flags, params->paramSize, params->what);
+		for (int i = 0; i < params->paramSize; ++i) {
+			printf ("[%d]:%d(0x%x), ", i, params->params[i], params->params[i]);
+		}
+		printf("\n\tsel:%d\n", sel);
+*/
+}
+
+#endif
+
+#if CA_DO_NOT_USE_AUDIO_COMPONENT 
+static OSStatus ComponentBase_GetComponentDescription (const AudioComponentInstance & inInstance, AudioComponentDescription &outDesc);
+#endif
+
+AudioComponentDescription ComponentBase::GetComponentDescription() const
+{
+	AudioComponentDescription desc;
+	OSStatus result = 1;
+	
+	if (IsPluginObject()) {
+		ca_require_noerr(result = CB_GetComponentDescription (mComponentInstance, &desc), home);
+	}
+#if !CA_USE_AUDIO_PLUGIN_ONLY
+	else {
+		ca_require_noerr(result = CMgr_GetComponentDescription (mComponentInstance, &desc), home);	
+	}
+#endif
+
+home:
+	if (result)
+		memset (&desc, 0, sizeof(AudioComponentDescription));
+	
+	return desc;
+}
+
+#if CA_USE_AUDIO_PLUGIN_ONLY
+// everything we need is there and we should be linking against it
+static OSStatus CB_GetComponentDescription (const AudioComponentInstance inInstance, AudioComponentDescription * outDesc)
+{
+	AudioComponent comp = AudioComponentInstanceGetComponent(inInstance);
+	if (comp)
+		return AudioComponentGetDescription(comp, outDesc);
+
+	return kAudio_ParamError;
+}
+
+#elif !TARGET_OS_WIN32
+// these are the direct dependencies on ComponentMgr calls that an AU
+// that is a component mgr is dependent on
+
+// these are dynamically loaded so that these calls will work on Leopard
+#include <dlfcn.h>
+
+static OSStatus CB_GetComponentDescription (const AudioComponentInstance inInstance, AudioComponentDescription * outDesc)
+{
+	typedef AudioComponent (*AudioComponentInstanceGetComponentProc) (AudioComponentInstance);
+	static AudioComponentInstanceGetComponentProc aciGCProc = NULL;
+	
+	typedef OSStatus (*AudioComponentGetDescriptionProc)(AudioComponent, AudioComponentDescription *);
+	static AudioComponentGetDescriptionProc acGDProc = NULL;
+	
+	static int doneInit = 0;
+	if (doneInit == 0) {
+		doneInit = 1;	
+		void* theImage = dlopen("/System/Library/Frameworks/AudioUnit.framework/AudioUnit", RTLD_LAZY);
+		if (theImage != NULL)
+		{
+			aciGCProc = (AudioComponentInstanceGetComponentProc)dlsym (theImage, "AudioComponentInstanceGetComponent");
+			if (aciGCProc) {
+				acGDProc = (AudioComponentGetDescriptionProc)dlsym (theImage, "AudioComponentGetDescription");
+			}
+		}
+	}
+	
+	OSStatus result = kAudio_UnimplementedError;
+	if (acGDProc && aciGCProc) {
+		AudioComponent comp = (*aciGCProc)(inInstance);
+		if (comp)
+			result = (*acGDProc)(comp, outDesc);
+	} 
+#if !CA_USE_AUDIO_PLUGIN_ONLY
+	else {
+		result = CMgr_GetComponentDescription (inInstance, outDesc);
+	}
+#endif
+
+	return result;
+}
+
+#if !CA_USE_AUDIO_PLUGIN_ONLY
+// these are the direct dependencies on ComponentMgr calls that an AU
+// that is a component mgr is dependent on
+
+// these are dynamically loaded
+
+#include <CoreServices/CoreServices.h>
+#include <AudioUnit/AudioUnit.h>
+#include "CAXException.h"
+#include "ComponentBase.h"
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Component Manager
+// Used for fast dispatch with audio units
+typedef Handle (*GetComponentInstanceStorageProc)(ComponentInstance aComponentInstance);
+static GetComponentInstanceStorageProc sGetComponentInstanceStorageProc = NULL;
+
+typedef OSErr (*GetComponentInfoProc)(Component, ComponentDescription *, void*, void*, void*);
+static GetComponentInfoProc sGetComponentInfoProc = NULL;
+
+typedef void (*SetComponentInstanceStorageProc)(ComponentInstance, Handle);
+static SetComponentInstanceStorageProc sSetComponentInstanceStorageProc = NULL;
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+static void CSInitOnce(void* /*unused*/)
+{
+	void *theImage = dlopen("/System/Library/Frameworks/CoreServices.framework/CoreServices", RTLD_LAZY);
+	if (!theImage) return;
+
+	sGetComponentInstanceStorageProc = (GetComponentInstanceStorageProc) dlsym(theImage, "GetComponentInstanceStorage");
+	sGetComponentInfoProc = (GetComponentInfoProc)dlsym (theImage, "GetComponentInfo");
+	sSetComponentInstanceStorageProc = (SetComponentInstanceStorageProc) dlsym(theImage, "SetComponentInstanceStorage");
+}
+
+#if TARGET_OS_MAC
+
+#include <dispatch/dispatch.h>
+
+static dispatch_once_t sCSInitOnce = 0;
+
+static void CSInit ()
+{
+	dispatch_once_f(&sCSInitOnce, NULL, CSInitOnce);
+}
+
+#else 
+
+static void CSInit ()
+{
+	static int sDoCSLoad = 1;
+	if (sDoCSLoad) {
+		sDoCSLoad = 0;
+		CSInitOnce(NULL);
+	}
+}
+
+#endif
+
+OSStatus CMgr_GetComponentDescription (const AudioComponentInstance inInstance, AudioComponentDescription * outDesc)
+{
+	CSInit();
+	if (sGetComponentInfoProc)
+		return (*sGetComponentInfoProc)((Component)inInstance, (ComponentDescription*)outDesc, NULL, NULL, NULL);
+	return kAudio_UnimplementedError;
+}
+
+Handle CMgr_GetComponentInstanceStorage(ComponentInstance aComponentInstance)
+{
+	CSInit();
+	if (sGetComponentInstanceStorageProc)
+		return (*sGetComponentInstanceStorageProc)(aComponentInstance);
+	return NULL;
+}
+
+void CMgr_SetComponentInstanceStorage(ComponentInstance aComponentInstance, Handle theStorage)
+{
+	CSInit();
+	if (sSetComponentInstanceStorageProc)
+		(*sSetComponentInstanceStorageProc)(aComponentInstance, theStorage);
+}
+#endif // !CA_USE_AUDIO_PLUGIN_ONLY
+
+#else
+//#include "ComponentManagerDependenciesWin.h"
+// everything we need is there and we should be linking against it
+static OSStatus CB_GetComponentDescription (const AudioComponentInstance inInstance, AudioComponentDescription * outDesc)
+{
+	AudioComponent comp = AudioComponentInstanceGetComponent(inInstance);
+	if (comp)
+		return AudioComponentGetDescription(comp, outDesc);
+
+	return kAudio_ParamError;
+}
+
+#endif
+

cyfaust/resources/architecture/AU/AUPublic/AUBase/ComponentBase.h

@@ -0,0 +1,340 @@
+/*
+     File: ComponentBase.h 
+ Abstract:  Part of CoreAudio Utility Classes  
+  Version: 1.01 
+  
+ Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple 
+ Inc. ("Apple") in consideration of your agreement to the following 
+ terms, and your use, installation, modification or redistribution of 
+ this Apple software constitutes acceptance of these terms.  If you do 
+ not agree with these terms, please do not use, install, modify or 
+ redistribute this Apple software. 
+  
+ In consideration of your agreement to abide by the following terms, and 
+ subject to these terms, Apple grants you a personal, non-exclusive 
+ license, under Apple's copyrights in this original Apple software (the 
+ "Apple Software"), to use, reproduce, modify and redistribute the Apple 
+ Software, with or without modifications, in source and/or binary forms; 
+ provided that if you redistribute the Apple Software in its entirety and 
+ without modifications, you must retain this notice and the following 
+ text and disclaimers in all such redistributions of the Apple Software. 
+ Neither the name, trademarks, service marks or logos of Apple Inc. may 
+ be used to endorse or promote products derived from the Apple Software 
+ without specific prior written permission from Apple.  Except as 
+ expressly stated in this notice, no other rights or licenses, express or 
+ implied, are granted by Apple herein, including but not limited to any 
+ patent rights that may be infringed by your derivative works or by other 
+ works in which the Apple Software may be incorporated. 
+  
+ The Apple Software is provided by Apple on an "AS IS" basis.  APPLE 
+ MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION 
+ THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS 
+ FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND 
+ OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS. 
+  
+ IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL 
+ OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, 
+ MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED 
+ AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), 
+ STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE 
+ POSSIBILITY OF SUCH DAMAGE. 
+  
+ Copyright (C) 2012 Apple Inc. All Rights Reserved. 
+  
+*/
+#ifndef __ComponentBase_h__
+#define __ComponentBase_h__
+
+#include <new>
+#include "CADebugMacros.h"
+#include "CAXException.h"
+
+#if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
+	#include <CoreAudio/CoreAudioTypes.h>
+	#include <AudioUnit/AudioUnit.h>
+
+	#if !CA_USE_AUDIO_PLUGIN_ONLY
+		#include <CoreServices/../Frameworks/CarbonCore.framework/Headers/Components.h>
+	
+		#if	(MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_5)
+			#define AudioComponentInstance			ComponentInstance
+			#define AudioComponentDescription		ComponentDescription
+			#define	AudioComponent					Component
+		#endif
+		Handle CMgr_GetComponentInstanceStorage(ComponentInstance aComponentInstance);
+		void CMgr_SetComponentInstanceStorage(ComponentInstance aComponentInstance, Handle theStorage);
+	#endif
+
+	#if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4
+		typedef Float32 AudioUnitParameterValue;
+	#endif
+	#if COREAUDIOTYPES_VERSION < 1051
+		typedef Float32 AudioUnitSampleType;
+	#endif
+
+	#if !TARGET_OS_WIN32
+		#include <pthread.h>
+	#endif
+
+	#if TARGET_OS_WIN32
+		#include "CAGuard.h"
+	#endif
+#else
+	#include "CoreAudioTypes.h"
+	#if !CA_USE_AUDIO_PLUGIN_ONLY
+		#include "ComponentManagerDependenciesWin.h"
+	#endif
+	#include "AudioUnit.h"
+	#include "CAGuard.h"
+#endif
+
+#ifndef COMPONENT_THROW
+	#if VERBOSE_COMPONENT_THROW
+		#define COMPONENT_THROW(throw_err) \
+			do { DebugMessage(#throw_err); throw static_cast<OSStatus>(throw_err); } while (0)
+	#else
+		#define COMPONENT_THROW(throw_err) \
+			throw static_cast<OSStatus>(throw_err)
+	#endif
+#endif
+
+#define COMPONENT_CATCH \
+	catch (const CAXException &ex) { result = ex.mError; } \
+	catch (std::bad_alloc &) { result = kAudio_MemFullError; } \
+	catch (OSStatus catch_err) { result = catch_err; } \
+	catch (OSErr catch_err) { result = catch_err; } \
+	catch (...) { result = -1; }
+
+/*! @class ComponentBase */
+class ComponentBase {
+public:
+	// classic MacErrors
+	enum { noErr = 0};
+
+	/*! @ctor ComponentBase */
+				ComponentBase(AudioComponentInstance inInstance);
+				
+	/*! @dtor ~ComponentBase */
+	virtual 	~ComponentBase();
+	
+	/*! @method PostConstructor */
+	virtual void			PostConstructor();
+	
+	/*! @method PreDestructor */
+	virtual void			PreDestructor();
+
+#if !CA_USE_AUDIO_PLUGIN_ONLY
+	/*! @method Version */
+	virtual OSStatus		Version();
+
+	/*! @method ComponentEntryDispatch */
+	static OSStatus		ComponentEntryDispatch(ComponentParameters *p, ComponentBase *This);
+
+	/*! GetSelectorForCanDo */
+	static SInt16		GetSelectorForCanDo(ComponentParameters *params);
+#endif
+	
+	/*! @method GetComponentInstance */
+	AudioComponentInstance		GetComponentInstance() const { return mComponentInstance; }
+
+	/*! @method GetComponentDescription */
+	AudioComponentDescription	GetComponentDescription() const;
+
+	// This global variable is so that new instances know how they were instantiated: via the Component Manager, 
+	// or as AudioComponents. It's ugly, but preferable to altering the constructor of every class in the hierarchy.
+	// It's safe because construction is protected by ComponentInitLocker.
+	enum EInstanceType { kComponentMgrInstance, kAudioComponentInstance };
+	static EInstanceType sNewInstanceType;
+
+	/*! @method IsPluginObject */
+	bool			IsPluginObject () const { return mInstanceType == kAudioComponentInstance; }
+	/*! @method IsCMgrObject */
+	bool			IsCMgrObject () const { return mInstanceType == kComponentMgrInstance; }
+
+	/*! @method AP_Open */
+	static OSStatus AP_Open(void *self, AudioUnit compInstance);
+
+	/*! @method AP_Close */
+	static OSStatus AP_Close(void *self);
+	
+protected:
+	/*! @var mComponentInstance */
+	AudioComponentInstance		mComponentInstance;
+	EInstanceType				mInstanceType;
+};
+
+class ComponentInitLocker 
+{
+#if TARGET_OS_MAC
+public:
+	ComponentInitLocker() 
+	{ 
+		pthread_once(&sOnce, InitComponentInitLocker);
+		pthread_mutex_lock(&sComponentOpenMutex); 
+		mPreviousNewInstanceType = ComponentBase::sNewInstanceType;
+	}
+	~ComponentInitLocker() 
+	{ 
+		ComponentBase::sNewInstanceType = mPreviousNewInstanceType;
+		pthread_mutex_unlock(&sComponentOpenMutex); 
+	}
+private:
+	static pthread_mutex_t sComponentOpenMutex;
+	static pthread_once_t sOnce;
+	static void InitComponentInitLocker();
+	
+#elif TARGET_OS_WIN32
+public:
+	bool sNeedsUnlocking;
+	ComponentInitLocker() { sNeedsUnlocking = sComponentOpenGuard.Lock(); }
+	~ComponentInitLocker() { if(sNeedsUnlocking) { sComponentOpenGuard.Unlock(); } }
+private:
+	static CAGuard	sComponentOpenGuard;
+#endif
+	
+private:
+	ComponentBase::EInstanceType	mPreviousNewInstanceType;
+};
+
+/*! @class AudioComponentPlugInInstance */ 
+struct AudioComponentPlugInInstance {
+	AudioComponentPlugInInterface		mPlugInInterface;
+	void *								(*mConstruct)(void *memory, AudioComponentInstance ci);
+	void								(*mDestruct)(void *memory);
+	void *								mPad[2];				// pad to a 16-byte boundary (in either 32 or 64 bit mode)
+	UInt32								mInstanceStorage;		// the ACI implementation object is constructed into this memory
+																// this member is just a placeholder. it is aligned to a 16byte boundary
+};
+
+/*! @class APFactory */ 
+template <class APMethodLookup, class Implementor>
+class APFactory {
+public:
+	static void *Construct(void *memory, AudioComponentInstance compInstance)
+	{
+		return new(memory) Implementor(compInstance);
+	}
+	
+	static void Destruct(void *memory)
+	{
+		((Implementor *)memory)->~Implementor();
+	}
+
+	// This is the AudioComponentFactoryFunction. It returns an AudioComponentPlugInInstance.
+	// The actual implementation object is not created until Open().
+	static AudioComponentPlugInInterface *Factory(const AudioComponentDescription *inDesc) 
+	{
+		AudioComponentPlugInInstance *acpi = 
+				(AudioComponentPlugInInstance *)malloc( offsetof(AudioComponentPlugInInstance, mInstanceStorage) + sizeof(Implementor) );
+		acpi->mPlugInInterface.Open = ComponentBase::AP_Open;
+		acpi->mPlugInInterface.Close = ComponentBase::AP_Close;
+		acpi->mPlugInInterface.Lookup = APMethodLookup::Lookup;
+		acpi->mPlugInInterface.reserved = NULL;
+		acpi->mConstruct = Construct;
+		acpi->mDestruct = Destruct;
+		acpi->mPad[0] = NULL;
+		acpi->mPad[1] = NULL;
+		return (AudioComponentPlugInInterface*)acpi;
+	}
+	
+	// This is for runtime registration (not for plug-ins loaded from bundles).
+	static AudioComponent Register(UInt32 type, UInt32 subtype, UInt32 manuf, CFStringRef name, UInt32 vers, UInt32 flags=0)
+	{
+		AudioComponentDescription desc = { type, subtype, manuf, flags, 0 };
+		return AudioComponentRegister(&desc, name, vers, Factory); 
+	}
+};
+
+#if !CA_USE_AUDIO_PLUGIN_ONLY
+/*! @class ComponentEntryPoint 
+ *	@discussion This is only used for a component manager version
+*/
+template <class Class>
+class ComponentEntryPoint {
+public:
+	/*! @method Dispatch */
+	static OSStatus Dispatch(ComponentParameters *params, Class *obj)
+	{
+		OSStatus result = noErr;
+		
+		try {
+			if (params->what == kComponentOpenSelect) {
+				// solve a host of initialization thread safety issues.
+				ComponentInitLocker lock;
+
+				ComponentBase::sNewInstanceType = ComponentBase::kComponentMgrInstance;
+				ComponentInstance ci = (ComponentInstance)(params->params[0]);
+				Class *This = new Class((AudioComponentInstance)ci);
+				This->PostConstructor();	// allows base class to do additional initialization
+											// once the derived class is fully constructed
+				
+				CMgr_SetComponentInstanceStorage(ci, (Handle)This);
+			} else
+				result = Class::ComponentEntryDispatch(params, obj);
+		}
+		COMPONENT_CATCH
+		
+		return result;
+	}
+	
+	/*! @method Register */
+	static Component Register(OSType compType, OSType subType, OSType manufacturer)
+	{
+		ComponentDescription	description = {compType, subType, manufacturer, 0, 0};
+		Component	component = RegisterComponent(&description, (ComponentRoutineUPP) Dispatch, registerComponentGlobal, NULL, NULL, NULL);
+		if (component != NULL) {
+			SetDefaultComponent(component, defaultComponentAnyFlagsAnyManufacturerAnySubType);
+		}
+		return component;
+	}
+};
+
+// these are the macros that are used to generate the Entry Points for a given Audio Plugin
+#if CA_USE_AUDIO_PLUGIN_ONLY
+	#define AUDIOCOMPONENT_ENTRY(FactoryType, Class) \
+		extern "C" void * Class##Factory(const AudioComponentDescription *inDesc); \
+		extern "C" void * Class##Factory(const AudioComponentDescription *inDesc) { \
+			return FactoryType<Class>::Factory(inDesc); \
+		}
+#else
+		// you should be using this macros as it registers both
+		// a plugin and a component mgr version. this can and should be used 
+		// with new and existing audio components (backwards compatible to SL)
+	#define AUDIOCOMPONENT_ENTRY(FactoryType, Class) \
+		extern "C" OSStatus Class##Entry(ComponentParameters *params, Class *obj); \
+		extern "C" OSStatus Class##Entry(ComponentParameters *params, Class *obj) { \
+			return ComponentEntryPoint<Class>::Dispatch(params, obj); \
+		} \
+		extern "C" void * Class##Factory(const AudioComponentDescription *inDesc); \
+		extern "C" void * Class##Factory(const AudioComponentDescription *inDesc) { \
+			return FactoryType<Class>::Factory(inDesc); \
+		}
+		// the only component we still support are the carbon based view components
+		// you should be using this macro now to exclusively register those types
+	#define VIEW_COMPONENT_ENTRY(Class) \
+		extern "C" OSStatus Class##Entry(ComponentParameters *params, Class *obj); \
+		extern "C" OSStatus Class##Entry(ComponentParameters *params, Class *obj) { \
+			return ComponentEntryPoint<Class>::Dispatch(params, obj); \
+		}
+#endif	
+
+	/*! @class ComponentRegistrar */
+template <class Class, OSType Type, OSType Subtype, OSType Manufacturer>
+class ComponentRegistrar {
+public:
+	/*! @ctor ComponentRegistrar */
+	ComponentRegistrar() { ComponentEntryPoint<Class>::Register(Type, Subtype, Manufacturer); }
+};
+
+#define	COMPONENT_REGISTER(Class,Type,Subtype,Manufacturer) \
+	static ComponentRegistrar<Class, Type, Subtype, Manufacturer>	gRegistrar##Class
+#else
+#define COMPONENT_ENTRY(Class)
+#define COMPONENT_REGISTER(Class)
+#define AUDIOCOMPONENT_ENTRY(FactoryType, Class)
+#endif // !CA_USE_AUDIO_PLUGIN_ONLY
+
+
+#endif // __ComponentBase_h__