// ****************************************************************************// File:			IASIOThiscallResolver.h// Description:     The IASIOThiscallResolver class implements the IASIO//					interface and acts as a proxy to the real IASIO interface by//                  calling through its vptr table using the thiscall calling//                  convention. To put it another way, we interpose//                  IASIOThiscallResolver between ASIO SDK code and the driver.//                  This is necessary because most non-Microsoft compilers don't//                  implement the thiscall calling convention used by IASIO.////					iasiothiscallresolver.cpp contains the background of this//					problem plus a technical description of the vptr//                  manipulations.////					In order to use this mechanism one simply has to add//					iasiothiscallresolver.cpp to the list of files to compile//                  and #include <iasiothiscallresolver.h>////					Note that this #include must come after the other ASIO SDK//                  #includes, for example:////					#include <windows.h>//					#include <asiosys.h>//					#include <asio.h>//					#include <asiodrivers.h>//					#include <iasiothiscallresolver.h>////					Actually the important thing is to #include//                  <iasiothiscallresolver.h> after <asio.h>. We have//                  incorporated a test to enforce this ordering.////					The code transparently takes care of the interposition by//                  using macro substitution to intercept calls to ASIOInit()//                  and ASIOExit(). We save the original ASIO global//                  "theAsioDriver" in our "that" variable, and then set//                  "theAsioDriver" to equal our IASIOThiscallResolver instance.//// 					Whilst this method of resolving the thiscall problem requires//					the addition of #include <iasiothiscallresolver.h> to client//                  code it has the advantage that it does not break the terms//                  of the ASIO licence by publishing it. We are NOT modifying//                  any Steinberg code here, we are merely implementing the IASIO//					interface in the same way that we would need to do if we//					wished to provide an open source ASIO driver.////					For compilation with MinGW -lole32 needs to be added to the//                  linker options. For BORLAND, linking with Import32.lib is//                  sufficient.////					The dependencies are with: CoInitialize, CoUninitialize,//					CoCreateInstance, CLSIDFromString - used by asiolist.cpp//					and are required on Windows whether ThiscallResolver is used//					or not.////					Searching for the above strings in the root library path//					of your compiler should enable the correct libraries to be//					identified if they aren't immediately obvious.////                  Note that the current implementation of IASIOThiscallResolver//                  is not COM compliant - it does not correctly implement the//                  IUnknown interface. Implementing it is not necessary because//                  it is not called by parts of the ASIO SDK which call through//                  theAsioDriver ptr. The IUnknown methods are implemented as//                  assert(false) to ensure that the code fails if they are//                  ever called.// Restrictions:	None. Public Domain & Open Source distribute freely//					You may use IASIOThiscallResolver commercially as well as//                  privately.//					You the user assume the responsibility for the use of the//					files, binary or text, and there is no guarantee or warranty,//					expressed or implied, including but not limited to the//					implied warranties of merchantability and fitness for a//					particular purpose. You assume all responsibility and agree//					to hold no entity, copyright holder or distributors liable//					for any loss of data or inaccurate representations of data//					as a result of using IASIOThiscallResolver.// Version:         1.4 Added separate macro CALL_THISCALL_1_DOUBLE from//                  Andrew Baldwin, and volatile for whole gcc asm blocks,//                  both for compatibility with newer gcc versions. Cleaned up//                  Borland asm to use one less register.//                  1.3 Switched to including assert.h for better compatibility.//                  Wrapped entire .h and .cpp contents with a check for//                  _MSC_VER to provide better compatibility with MS compilers.//                  Changed Singleton implementation to use static instance//                  instead of freestore allocated instance. Removed ASIOExit//                  macro as it is no longer needed.//                  1.2 Removed semicolons from ASIOInit and ASIOExit macros to//                  allow them to be embedded in expressions (if statements).//                  Cleaned up some comments. Removed combase.c dependency (it//                  doesn't compile with BCB anyway) by stubbing IUnknown.//                  1.1 Incorporated comments from Ross Bencina including things//					such as changing name from ThiscallResolver to//					IASIOThiscallResolver, tidying up the constructor, fixing//					a bug in IASIOThiscallResolver::ASIOExit() and improving//					portability through the use of conditional compilation//					1.0 Initial working version.// Created:			6/09/2003// Authors:         Fraser Adams//                  Ross Bencina//                  Rene G. Ceballos//                  Martin Fay//                  Antti Silvast//                  Andrew Baldwin//// ****************************************************************************#ifndef included_iasiothiscallresolver_h#define included_iasiothiscallresolver_h// We only need IASIOThiscallResolver at all if we are on Win32. For other// platforms we simply bypass the IASIOThiscallResolver definition to allow us// to be safely #include'd whatever the platform to keep client code portable#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)// If microsoft compiler we can call IASIO directly so IASIOThiscallResolver// is not used.#if !defined(_MSC_VER)// The following is in order to ensure that this header is only included after// the other ASIO headers (except for the case of iasiothiscallresolver.cpp).// We need to do this because IASIOThiscallResolver works by eclipsing the// original definition of ASIOInit() with a macro (see below).#if !defined(iasiothiscallresolver_sourcefile)	#if !defined(__ASIO_H)	#error iasiothiscallresolver.h must be included AFTER asio.h	#endif#endif#include <windows.h>#include <asiodrvr.h> /* From ASIO SDK */class IASIOThiscallResolver : public IASIO {private:	IASIO* that_; // Points to the real IASIO	static IASIOThiscallResolver instance; // Singleton instance	// Constructors - declared private so construction is limited to    // our Singleton instance    IASIOThiscallResolver();	IASIOThiscallResolver(IASIO* that);public:    // Methods from the IUnknown interface. We don't fully implement IUnknown    // because the ASIO SDK never calls these methods through theAsioDriver ptr.    // These methods are implemented as assert(false).    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppv);    virtual ULONG STDMETHODCALLTYPE AddRef();    virtual ULONG STDMETHODCALLTYPE Release();    // Methods from the IASIO interface, implemented as forwarning calls to that.	virtual ASIOBool init(void *sysHandle);	virtual void getDriverName(char *name);	virtual long getDriverVersion();	virtual void getErrorMessage(char *string);	virtual ASIOError start();	virtual ASIOError stop();	virtual ASIOError getChannels(long *numInputChannels, long *numOutputChannels);	virtual ASIOError getLatencies(long *inputLatency, long *outputLatency);	virtual ASIOError getBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity);	virtual ASIOError canSampleRate(ASIOSampleRate sampleRate);	virtual ASIOError getSampleRate(ASIOSampleRate *sampleRate);	virtual ASIOError setSampleRate(ASIOSampleRate sampleRate);	virtual ASIOError getClockSources(ASIOClockSource *clocks, long *numSources);	virtual ASIOError setClockSource(long reference);	virtual ASIOError getSamplePosition(ASIOSamples *sPos, ASIOTimeStamp *tStamp);	virtual ASIOError getChannelInfo(ASIOChannelInfo *info);	virtual ASIOError createBuffers(ASIOBufferInfo *bufferInfos, long numChannels, long bufferSize, ASIOCallbacks *callbacks);	virtual ASIOError disposeBuffers();	virtual ASIOError controlPanel();	virtual ASIOError future(long selector,void *opt);	virtual ASIOError outputReady();    // Class method, see ASIOInit() macro below.    static ASIOError ASIOInit(ASIODriverInfo *info); // Delegates to ::ASIOInit};// Replace calls to ASIOInit with our interposing version.// This macro enables us to perform thiscall resolution simply by #including// <iasiothiscallresolver.h> after the asio #includes (this file _must_ be// included _after_ the asio #includes)#define ASIOInit(name) IASIOThiscallResolver::ASIOInit((name))#endif /* !defined(_MSC_VER) */#endif /* Win32 */#endif /* included_iasiothiscallresolver_h */