drivers/audio/iasiothiscallresolver.cpp

/*
        IASIOThiscallResolver.cpp see the comments in iasiothiscallresolver.h for
    the top level description - this comment describes the technical details of
    the implementation.

    The latest version of this file is available from:
    http://www.audiomulch.com/~rossb/code/calliasio

    please email comments to Ross Bencina <rossb@audiomulch.com>

    BACKGROUND

    The IASIO interface declared in the Steinberg ASIO 2 SDK declares
    functions with no explicit calling convention. This causes MSVC++ to default
    to using the thiscall convention, which is a proprietary convention not
    implemented by some non-microsoft compilers - notably borland BCC,
    C++Builder, and gcc. MSVC++ is the defacto standard compiler used by
    Steinberg. As a result of this situation, the ASIO sdk will compile with
    any compiler, however attempting to execute the compiled code will cause a
    crash due to different default calling conventions on non-Microsoft
    compilers.

    IASIOThiscallResolver solves the problem by providing an adapter class that
    delegates to the IASIO interface using the correct calling convention
    (thiscall). Due to the lack of support for thiscall in the Borland and GCC
    compilers, the calls have been implemented in assembly language.

    A number of macros are defined for thiscall function calls with different
    numbers of parameters, with and without return values - it may be possible
    to modify the format of these macros to make them work with other inline
    assemblers.


    THISCALL DEFINITION

    A number of definitions of the thiscall calling convention are floating
    around the internet. The following definition has been validated against
    output from the MSVC++ compiler:

    For non-vararg functions, thiscall works as follows: the object (this)
    pointer is passed in ECX. All arguments are passed on the stack in
    right to left order. The return value is placed in EAX. The callee
    clears the passed arguments from the stack.


    FINDING FUNCTION POINTERS FROM AN IASIO POINTER

    The first field of a COM object is a pointer to its vtble. Thus a pointer
    to an object implementing the IASIO interface also points to a pointer to
    that object's vtbl. The vtble is a table of function pointers for all of
    the virtual functions exposed by the implemented interfaces.

    If we consider a variable declared as a pointer to IASO:

    IASIO *theAsioDriver

    theAsioDriver points to:

    object implementing IASIO
    {
        IASIOvtbl *vtbl
        other data
    }

    in other words, theAsioDriver points to a pointer to an IASIOvtbl

    vtbl points to a table of function pointers:

    IASIOvtbl ( interface IASIO : public IUnknown )
    {
    (IUnknown functions)
    0   virtual HRESULT STDMETHODCALLTYPE (*QueryInterface)(REFIID riid, void **ppv) = 0;
    4   virtual ULONG STDMETHODCALLTYPE (*AddRef)() = 0;
    8   virtual ULONG STDMETHODCALLTYPE (*Release)() = 0;

    (IASIO functions)
    12  virtual ASIOBool (*init)(void *sysHandle) = 0;
    16  virtual void (*getDriverName)(char *name) = 0;
    20  virtual long (*getDriverVersion)() = 0;
    24  virtual void (*getErrorMessage)(char *string) = 0;
    28  virtual ASIOError (*start)() = 0;
    32  virtual ASIOError (*stop)() = 0;
    36  virtual ASIOError (*getChannels)(long *numInputChannels, long *numOutputChannels) = 0;
    40  virtual ASIOError (*getLatencies)(long *inputLatency, long *outputLatency) = 0;
    44  virtual ASIOError (*getBufferSize)(long *minSize, long *maxSize,
            long *preferredSize, long *granularity) = 0;
    48  virtual ASIOError (*canSampleRate)(ASIOSampleRate sampleRate) = 0;
    52  virtual ASIOError (*getSampleRate)(ASIOSampleRate *sampleRate) = 0;
    56  virtual ASIOError (*setSampleRate)(ASIOSampleRate sampleRate) = 0;
    60  virtual ASIOError (*getClockSources)(ASIOClockSource *clocks, long *numSources) = 0;
    64  virtual ASIOError (*setClockSource)(long reference) = 0;
    68  virtual ASIOError (*getSamplePosition)(ASIOSamples *sPos, ASIOTimeStamp *tStamp) = 0;
    72  virtual ASIOError (*getChannelInfo)(ASIOChannelInfo *info) = 0;
    76  virtual ASIOError (*createBuffers)(ASIOBufferInfo *bufferInfos, long numChannels,
            long bufferSize, ASIOCallbacks *callbacks) = 0;
    80  virtual ASIOError (*disposeBuffers)() = 0;
    84  virtual ASIOError (*controlPanel)() = 0;
    88  virtual ASIOError (*future)(long selector,void *opt) = 0;
    92  virtual ASIOError (*outputReady)() = 0;
    };

    The numbers in the left column show the byte offset of each function ptr
    from the beginning of the vtbl. These numbers are used in the code below
    to select different functions.

    In order to find the address of a particular function, theAsioDriver
    must first be dereferenced to find the value of the vtbl pointer:

    mov     eax, theAsioDriver
    mov     edx, [theAsioDriver]  // edx now points to vtbl[0]

    Then an offset must be added to the vtbl pointer to select a
    particular function, for example vtbl+44 points to the slot containing
    a pointer to the getBufferSize function.

    Finally vtbl+x must be dereferenced to obtain the value of the function
    pointer stored in that address:

    call    [edx+44]    // call the function pointed to by
                        // the value in the getBufferSize field of the vtbl


    SEE ALSO

    Martin Fay's OpenASIO DLL at http://www.martinfay.com solves the same
    problem by providing a new COM interface which wraps IASIO with an
    interface that uses portable calling conventions. OpenASIO must be compiled
    with MSVC, and requires that you ship the OpenASIO DLL with your
    application.


    ACKNOWLEDGEMENTS

    Ross Bencina: worked out the thiscall details above, wrote the original
    Borland asm macros, and a patch for asio.cpp (which is no longer needed).
    Thanks to Martin Fay for introducing me to the issues discussed here,
    and to Rene G. Ceballos for assisting with asm dumps from MSVC++.

    Antti Silvast: converted the original calliasio to work with gcc and NASM
    by implementing the asm code in a separate file.

        Fraser Adams: modified the original calliasio containing the Borland inline
    asm to add inline asm for gcc i.e. Intel syntax for Borland and AT&T syntax
    for gcc. This seems a neater approach for gcc than to have a separate .asm
    file and it means that we only need one version of the thiscall patch.

    Fraser Adams: rewrote the original calliasio patch in the form of the
    IASIOThiscallResolver class in order to avoid modifications to files from
    the Steinberg SDK, which may have had potential licence issues.

    Andrew Baldwin: contributed fixes for compatibility problems with more
    recent versions of the gcc assembler.
*/


// 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__)

// gcc 4.4 is using the same calling conventions as Microsoft on Win64
#if !defined(__WIN64__)

// If microsoft compiler we can call IASIO directly so IASIOThiscallResolver
// is not used.
#if !defined(_MSC_VER)

#include <new>
#include <assert.h>

// We have a mechanism in iasiothiscallresolver.h to ensure that asio.h is
// #include'd before it in client code, we do NOT want to do this test here.
#define iasiothiscallresolver_sourcefile 1
#include "iasiothiscallresolver.h"
#undef iasiothiscallresolver_sourcefile

// iasiothiscallresolver.h redefines ASIOInit for clients, but we don't want
// this macro defined in this translation unit.
#undef ASIOInit

// theAsioDriver is a global pointer to the current IASIO instance which the
// ASIO SDK uses to perform all actions on the IASIO interface. We substitute
// our own forwarding interface into this pointer.
extern IASIO* theAsioDriver;

// The following macros define the inline assembler for BORLAND first then gcc

#if defined(__BCPLUSPLUS__) || defined(__BORLANDC__)

#define CALL_THISCALL_0( resultName, thisPtr, funcOffset )\
    void *this_ = (thisPtr);                                                \
    __asm {                                                                 \
        mov     ecx, this_            ;                                     \
        mov     eax, [ecx]            ;                                     \
        call    [eax+funcOffset]      ;                                     \
        mov     resultName, eax       ;                                     \
    }

#define CALL_VOID_THISCALL_1( thisPtr, funcOffset, param1 )\
    void *this_ = (thisPtr);                                                \
    __asm {                                                                 \
        mov     eax, param1           ;                                     \
        push    eax                   ;                                     \
        mov     ecx, this_            ;                                     \
        mov     eax, [ecx]            ;                                     \
        call    [eax+funcOffset]      ;                                     \
    }

#define CALL_THISCALL_1( resultName, thisPtr, funcOffset, param1 )\
    void *this_ = (thisPtr);                                                \
    __asm {                                                                 \
        mov     eax, param1           ;                                     \
        push    eax                   ;                                     \
        mov     ecx, this_            ;                                     \
        mov     eax, [ecx]            ;                                     \
        call    [eax+funcOffset]      ;                                     \
        mov     resultName, eax       ;                                     \
    }

#define CALL_THISCALL_1_DOUBLE( resultName, thisPtr, funcOffset, param1 )\
    void *this_ = (thisPtr);                                                \
    void *doubleParamPtr_ (&param1);                                        \
    __asm {                                                                 \
        mov     eax, doubleParamPtr_  ;                                     \
        push    [eax+4]               ;                                     \
        push    [eax]                 ;                                     \
        mov     ecx, this_            ;                                     \
        mov     eax, [ecx]            ;                                     \
        call    [eax+funcOffset]      ;                                     \
        mov     resultName, eax       ;                                     \
    }

#define CALL_THISCALL_2( resultName, thisPtr, funcOffset, param1, param2 )\
    void *this_ = (thisPtr);                                                \
    __asm {                                                                 \
        mov     eax, param2           ;                                     \
        push    eax                   ;                                     \
        mov     eax, param1           ;                                     \
        push    eax                   ;                                     \
        mov     ecx, this_            ;                                     \
        mov     eax, [ecx]            ;                                     \
        call    [eax+funcOffset]      ;                                     \
        mov     resultName, eax       ;                                     \
    }

#define CALL_THISCALL_4( resultName, thisPtr, funcOffset, param1, param2, param3, param4 )\
    void *this_ = (thisPtr);                                                \
    __asm {                                                                 \
        mov     eax, param4           ;                                     \
        push    eax                   ;                                     \
        mov     eax, param3           ;                                     \
        push    eax                   ;                                     \
        mov     eax, param2           ;                                     \
        push    eax                   ;                                     \
        mov     eax, param1           ;                                     \
        push    eax                   ;                                     \
        mov     ecx, this_            ;                                     \
        mov     eax, [ecx]            ;                                     \
        call    [eax+funcOffset]      ;                                     \
        mov     resultName, eax       ;                                     \
    }

#elif defined(__GNUC__)

#define CALL_THISCALL_0( resultName, thisPtr, funcOffset )                  \
    __asm__ __volatile__ ("movl (%1), %%edx\n\t"                            \
                          "call *"#funcOffset"(%%edx)\n\t"                  \
                          :"=a"(resultName) /* Output Operands */           \
                          :"c"(thisPtr)     /* Input Operands */            \
                          : "%edx" /* Clobbered Registers */                \
                         );                                                 \

#define CALL_VOID_THISCALL_1( thisPtr, funcOffset, param1 )                 \
    __asm__ __volatile__ ("pushl %0\n\t"                                    \
                          "movl (%1), %%edx\n\t"                            \
                          "call *"#funcOffset"(%%edx)\n\t"                  \
                          :                 /* Output Operands */           \
                          :"r"(param1),     /* Input Operands */            \
                           "c"(thisPtr)                                     \
                          : "%edx" /* Clobbered Registers */                \
                         );                                                 \

#define CALL_THISCALL_1( resultName, thisPtr, funcOffset, param1 )          \
    __asm__ __volatile__ ("pushl %1\n\t"                                    \
                          "movl (%2), %%edx\n\t"                            \
                          "call *"#funcOffset"(%%edx)\n\t"                  \
                          :"=a"(resultName) /* Output Operands */           \
                          :"r"(param1),     /* Input Operands */            \
                           "c"(thisPtr)                                     \
                          : "%edx" /* Clobbered Registers */                \
                          );                                                \

#define CALL_THISCALL_1_DOUBLE( resultName, thisPtr, funcOffset, param1 )   \
    do {                                                                    \
    double param1f64 = param1; /* Cast explicitly to double */              \
    double *param1f64Ptr = &param1f64; /* Make pointer to address */        \
     __asm__ __volatile__ ("pushl 4(%1)\n\t"                                \
                           "pushl (%1)\n\t"                                 \
                           "movl (%2), %%edx\n\t"                           \
                           "call *"#funcOffset"(%%edx);\n\t"                \
                           : "=a"(resultName) /* Output Operands */         \
                           : "r"(param1f64Ptr),  /* Input Operands */       \
                           "c"(thisPtr),                                    \
                           "m"(*param1f64Ptr) /* Using address */           \
                           : "%edx" /* Clobbered Registers */               \
                           );                                               \
    } while (0);                                                            \


#define CALL_THISCALL_2( resultName, thisPtr, funcOffset, param1, param2 )  \
    __asm__ __volatile__ ("pushl %1\n\t"                                    \
                          "pushl %2\n\t"                                    \
                          "movl (%3), %%edx\n\t"                            \
                          "call *"#funcOffset"(%%edx)\n\t"                  \
                          :"=a"(resultName) /* Output Operands */           \
                          :"r"(param2),     /* Input Operands */            \
                           "r"(param1),                                     \
                           "c"(thisPtr)                                     \
                          : "%edx" /* Clobbered Registers */                \
                          );                                                \

#define CALL_THISCALL_4( resultName, thisPtr, funcOffset, param1, param2, param3, param4 )\
    __asm__ __volatile__ ("pushl %1\n\t"                                    \
                          "pushl %2\n\t"                                    \
                          "pushl %3\n\t"                                    \
                          "pushl %4\n\t"                                    \
                          "movl (%5), %%edx\n\t"                            \
                          "call *"#funcOffset"(%%edx)\n\t"                  \
                          :"=a"(resultName) /* Output Operands */           \
                          :"r"(param4),     /* Input Operands  */           \
                           "r"(param3),                                     \
                           "r"(param2),                                     \
                           "r"(param1),                                     \
                           "c"(thisPtr)                                     \
                          : "%edx" /* Clobbered Registers */                \
                          );                                                \

#endif

// Our static singleton instance.
IASIOThiscallResolver IASIOThiscallResolver::instance;

// Constructor called to initialize static Singleton instance above. Note that
// it is important not to clear that_ incase it has already been set by the call
// to placement new in ASIOInit().
IASIOThiscallResolver::IASIOThiscallResolver()
{
}

// Constructor called from ASIOInit() below
IASIOThiscallResolver::IASIOThiscallResolver(IASIO* that)
: that_( that )
{
}

// Implement IUnknown methods as assert(false). IASIOThiscallResolver is not
// really a COM object, just a wrapper which will work with the ASIO SDK.
// If you wanted to use ASIO without the SDK you might want to implement COM
// aggregation in these methods.
HRESULT STDMETHODCALLTYPE IASIOThiscallResolver::QueryInterface(REFIID riid, void **ppv)
{
    (void)riid;     // suppress unused variable warning

    assert( false ); // this function should never be called by the ASIO SDK.

    *ppv = NULL;
    return E_NOINTERFACE;
}

ULONG STDMETHODCALLTYPE IASIOThiscallResolver::AddRef()
{
    assert( false ); // this function should never be called by the ASIO SDK.

    return 1;
}

ULONG STDMETHODCALLTYPE IASIOThiscallResolver::Release()
{
    assert( false ); // this function should never be called by the ASIO SDK.

    return 1;
}

// Implement the IASIO interface methods by performing the vptr manipulation
// described above then delegating to the real implementation.
ASIOBool IASIOThiscallResolver::init(void *sysHandle)
{
    ASIOBool result;
    CALL_THISCALL_1( result, that_, 12, sysHandle );
    return result;
}

void IASIOThiscallResolver::getDriverName(char *name)
{
    CALL_VOID_THISCALL_1( that_, 16, name );
}

long IASIOThiscallResolver::getDriverVersion()
{
    ASIOBool result;
    CALL_THISCALL_0( result, that_, 20 );
    return result;
}

void IASIOThiscallResolver::getErrorMessage(char *string)
{
     CALL_VOID_THISCALL_1( that_, 24, string );
}

ASIOError IASIOThiscallResolver::start()
{
    ASIOBool result;
    CALL_THISCALL_0( result, that_, 28 );
    return result;
}

ASIOError IASIOThiscallResolver::stop()
{
    ASIOBool result;
    CALL_THISCALL_0( result, that_, 32 );
    return result;
}

ASIOError IASIOThiscallResolver::getChannels(long *numInputChannels, long *numOutputChannels)
{
    ASIOBool result;
    CALL_THISCALL_2( result, that_, 36, numInputChannels, numOutputChannels );
    return result;
}

ASIOError IASIOThiscallResolver::getLatencies(long *inputLatency, long *outputLatency)
{
    ASIOBool result;
    CALL_THISCALL_2( result, that_, 40, inputLatency, outputLatency );
    return result;
}

ASIOError IASIOThiscallResolver::getBufferSize(long *minSize, long *maxSize,
        long *preferredSize, long *granularity)
{
    ASIOBool result;
    CALL_THISCALL_4( result, that_, 44, minSize, maxSize, preferredSize, granularity );
    return result;
}

ASIOError IASIOThiscallResolver::canSampleRate(ASIOSampleRate sampleRate)
{
    ASIOBool result;
    CALL_THISCALL_1_DOUBLE( result, that_, 48, sampleRate );
    return result;
}

ASIOError IASIOThiscallResolver::getSampleRate(ASIOSampleRate *sampleRate)
{
    ASIOBool result;
    CALL_THISCALL_1( result, that_, 52, sampleRate );
    return result;
}

ASIOError IASIOThiscallResolver::setSampleRate(ASIOSampleRate sampleRate)
{
    ASIOBool result;
    CALL_THISCALL_1_DOUBLE( result, that_, 56, sampleRate );
    return result;
}

ASIOError IASIOThiscallResolver::getClockSources(ASIOClockSource *clocks, long *numSources)
{
    ASIOBool result;
    CALL_THISCALL_2( result, that_, 60, clocks, numSources );
    return result;
}

ASIOError IASIOThiscallResolver::setClockSource(long reference)
{
    ASIOBool result;
    CALL_THISCALL_1( result, that_, 64, reference );
    return result;
}

ASIOError IASIOThiscallResolver::getSamplePosition(ASIOSamples *sPos, ASIOTimeStamp *tStamp)
{
    ASIOBool result;
    CALL_THISCALL_2( result, that_, 68, sPos, tStamp );
    return result;
}

ASIOError IASIOThiscallResolver::getChannelInfo(ASIOChannelInfo *info)
{
    ASIOBool result;
    CALL_THISCALL_1( result, that_, 72, info );
    return result;
}

ASIOError IASIOThiscallResolver::createBuffers(ASIOBufferInfo *bufferInfos,
        long numChannels, long bufferSize, ASIOCallbacks *callbacks)
{
    ASIOBool result;
    CALL_THISCALL_4( result, that_, 76, bufferInfos, numChannels, bufferSize, callbacks );
    return result;
}

ASIOError IASIOThiscallResolver::disposeBuffers()
{
    ASIOBool result;
    CALL_THISCALL_0( result, that_, 80 );
    return result;
}

ASIOError IASIOThiscallResolver::controlPanel()
{
    ASIOBool result;
    CALL_THISCALL_0( result, that_, 84 );
    return result;
}

ASIOError IASIOThiscallResolver::future(long selector,void *opt)
{
    ASIOBool result;
    CALL_THISCALL_2( result, that_, 88, selector, opt );
    return result;
}

ASIOError IASIOThiscallResolver::outputReady()
{
    ASIOBool result;
    CALL_THISCALL_0( result, that_, 92 );
    return result;
}

// Implement our substitute ASIOInit() method
ASIOError IASIOThiscallResolver::ASIOInit(ASIODriverInfo *info)
{
    // To ensure that our instance's vptr is correctly constructed, even if
    // ASIOInit is called prior to main(), we explicitly call its constructor
    // (potentially over the top of an existing instance). Note that this is
    // pretty ugly, and is only safe because IASIOThiscallResolver has no
    // destructor and contains no objects with destructors.
    new((void*)&instance) IASIOThiscallResolver( theAsioDriver );

    // Interpose between ASIO client code and the real driver.
    theAsioDriver = &instance;

    // Note that we never need to switch theAsioDriver back to point to the
    // real driver because theAsioDriver is reset to zero in ASIOExit().

    // Delegate to the real ASIOInit
        return ::ASIOInit(info);
}

#endif /* !defined(_MSC_VER) */
#endif /* !defined(__WIN64__) */
#endif /* Win32 */
1	/*
2	IASIOThiscallResolver.cpp see the comments in iasiothiscallresolver.h for
3	the top level description - this comment describes the technical details of
4	the implementation.
5
6	The latest version of this file is available from:
7	http://www.audiomulch.com/~rossb/code/calliasio
8
9	please email comments to Ross Bencina <rossb@audiomulch.com>
10
11	BACKGROUND
12
13	The IASIO interface declared in the Steinberg ASIO 2 SDK declares
14	functions with no explicit calling convention. This causes MSVC++ to default
15	to using the thiscall convention, which is a proprietary convention not
16	implemented by some non-microsoft compilers - notably borland BCC,
17	C++Builder, and gcc. MSVC++ is the defacto standard compiler used by
18	Steinberg. As a result of this situation, the ASIO sdk will compile with
19	any compiler, however attempting to execute the compiled code will cause a
20	crash due to different default calling conventions on non-Microsoft
21	compilers.
22
23	IASIOThiscallResolver solves the problem by providing an adapter class that
24	delegates to the IASIO interface using the correct calling convention
25	(thiscall). Due to the lack of support for thiscall in the Borland and GCC
26	compilers, the calls have been implemented in assembly language.
27
28	A number of macros are defined for thiscall function calls with different
29	numbers of parameters, with and without return values - it may be possible
30	to modify the format of these macros to make them work with other inline
31	assemblers.
32
33
34	THISCALL DEFINITION
35
36	A number of definitions of the thiscall calling convention are floating
37	around the internet. The following definition has been validated against
38	output from the MSVC++ compiler:
39
40	For non-vararg functions, thiscall works as follows: the object (this)
41	pointer is passed in ECX. All arguments are passed on the stack in
42	right to left order. The return value is placed in EAX. The callee
43	clears the passed arguments from the stack.
44
45
46	FINDING FUNCTION POINTERS FROM AN IASIO POINTER
47
48	The first field of a COM object is a pointer to its vtble. Thus a pointer
49	to an object implementing the IASIO interface also points to a pointer to
50	that object's vtbl. The vtble is a table of function pointers for all of
51	the virtual functions exposed by the implemented interfaces.
52
53	If we consider a variable declared as a pointer to IASO:
54
55	IASIO *theAsioDriver
56
57	theAsioDriver points to:
58
59	object implementing IASIO
60	{
61	IASIOvtbl *vtbl
62	other data
63	}
64
65	in other words, theAsioDriver points to a pointer to an IASIOvtbl
66
67	vtbl points to a table of function pointers:
68
69	IASIOvtbl ( interface IASIO : public IUnknown )
70	{
71	(IUnknown functions)
72	0 virtual HRESULT STDMETHODCALLTYPE (QueryInterface)(REFIID riid, void *ppv) = 0;
73	4 virtual ULONG STDMETHODCALLTYPE (*AddRef)() = 0;
74	8 virtual ULONG STDMETHODCALLTYPE (*Release)() = 0;
75
76	(IASIO functions)
77	12 virtual ASIOBool (init)(void sysHandle) = 0;
78	16 virtual void (getDriverName)(char name) = 0;
79	20 virtual long (*getDriverVersion)() = 0;
80	24 virtual void (getErrorMessage)(char string) = 0;
81	28 virtual ASIOError (*start)() = 0;
82	32 virtual ASIOError (*stop)() = 0;
83	36 virtual ASIOError (getChannels)(long numInputChannels, long *numOutputChannels) = 0;
84	40 virtual ASIOError (getLatencies)(long inputLatency, long *outputLatency) = 0;
85	44 virtual ASIOError (getBufferSize)(long minSize, long *maxSize,
86	long preferredSize, long granularity) = 0;
87	48 virtual ASIOError (*canSampleRate)(ASIOSampleRate sampleRate) = 0;
88	52 virtual ASIOError (getSampleRate)(ASIOSampleRate sampleRate) = 0;
89	56 virtual ASIOError (*setSampleRate)(ASIOSampleRate sampleRate) = 0;
90	60 virtual ASIOError (getClockSources)(ASIOClockSource clocks, long *numSources) = 0;
91	64 virtual ASIOError (*setClockSource)(long reference) = 0;
92	68 virtual ASIOError (getSamplePosition)(ASIOSamples sPos, ASIOTimeStamp *tStamp) = 0;
93	72 virtual ASIOError (getChannelInfo)(ASIOChannelInfo info) = 0;
94	76 virtual ASIOError (createBuffers)(ASIOBufferInfo bufferInfos, long numChannels,
95	long bufferSize, ASIOCallbacks *callbacks) = 0;
96	80 virtual ASIOError (*disposeBuffers)() = 0;
97	84 virtual ASIOError (*controlPanel)() = 0;
98	88 virtual ASIOError (future)(long selector,void opt) = 0;
99	92 virtual ASIOError (*outputReady)() = 0;
100	};
101
102	The numbers in the left column show the byte offset of each function ptr
103	from the beginning of the vtbl. These numbers are used in the code below
104	to select different functions.
105
106	In order to find the address of a particular function, theAsioDriver
107	must first be dereferenced to find the value of the vtbl pointer:
108
109	mov eax, theAsioDriver
110	mov edx, [theAsioDriver] // edx now points to vtbl[0]
111
112	Then an offset must be added to the vtbl pointer to select a
113	particular function, for example vtbl+44 points to the slot containing
114	a pointer to the getBufferSize function.
115
116	Finally vtbl+x must be dereferenced to obtain the value of the function
117	pointer stored in that address:
118
119	call [edx+44] // call the function pointed to by
120	// the value in the getBufferSize field of the vtbl
121
122
123	SEE ALSO
124
125	Martin Fay's OpenASIO DLL at http://www.martinfay.com solves the same
126	problem by providing a new COM interface which wraps IASIO with an
127	interface that uses portable calling conventions. OpenASIO must be compiled
128	with MSVC, and requires that you ship the OpenASIO DLL with your
129	application.
130
131
132	ACKNOWLEDGEMENTS
133
134	Ross Bencina: worked out the thiscall details above, wrote the original
135	Borland asm macros, and a patch for asio.cpp (which is no longer needed).
136	Thanks to Martin Fay for introducing me to the issues discussed here,
137	and to Rene G. Ceballos for assisting with asm dumps from MSVC++.
138
139	Antti Silvast: converted the original calliasio to work with gcc and NASM
140	by implementing the asm code in a separate file.
141
142	Fraser Adams: modified the original calliasio containing the Borland inline
143	asm to add inline asm for gcc i.e. Intel syntax for Borland and AT&T syntax
144	for gcc. This seems a neater approach for gcc than to have a separate .asm
145	file and it means that we only need one version of the thiscall patch.
146
147	Fraser Adams: rewrote the original calliasio patch in the form of the
148	IASIOThiscallResolver class in order to avoid modifications to files from
149	the Steinberg SDK, which may have had potential licence issues.
150
151	Andrew Baldwin: contributed fixes for compatibility problems with more
152	recent versions of the gcc assembler.
153	*/
154
155
156	// We only need IASIOThiscallResolver at all if we are on Win32. For other
157	// platforms we simply bypass the IASIOThiscallResolver definition to allow us
158	// to be safely #include'd whatever the platform to keep client code portable
159	#if defined(WIN32) \|\| defined(_WIN32) \|\| defined(__WIN32__)
160
161	// gcc 4.4 is using the same calling conventions as Microsoft on Win64
162	#if !defined(__WIN64__)
163
164	// If microsoft compiler we can call IASIO directly so IASIOThiscallResolver
165	// is not used.
166	#if !defined(_MSC_VER)
167
168	#include <new>
169	#include <assert.h>
170
171	// We have a mechanism in iasiothiscallresolver.h to ensure that asio.h is
172	// #include'd before it in client code, we do NOT want to do this test here.
173	#define iasiothiscallresolver_sourcefile 1
174	#include "iasiothiscallresolver.h"
175	#undef iasiothiscallresolver_sourcefile
176
177	// iasiothiscallresolver.h redefines ASIOInit for clients, but we don't want
178	// this macro defined in this translation unit.
179	#undef ASIOInit
180
181	// theAsioDriver is a global pointer to the current IASIO instance which the
182	// ASIO SDK uses to perform all actions on the IASIO interface. We substitute
183	// our own forwarding interface into this pointer.
184	extern IASIO* theAsioDriver;
185
186	// The following macros define the inline assembler for BORLAND first then gcc
187
188	#if defined(__BCPLUSPLUS__) \|\| defined(__BORLANDC__)
189
190	#define CALL_THISCALL_0( resultName, thisPtr, funcOffset )\
191	void *this_ = (thisPtr); \
192	__asm { \
193	mov ecx, this_ ; \
194	mov eax, [ecx] ; \
195	call [eax+funcOffset] ; \
196	mov resultName, eax ; \
197	}
198
199	#define CALL_VOID_THISCALL_1( thisPtr, funcOffset, param1 )\
200	void *this_ = (thisPtr); \
201	__asm { \
202	mov eax, param1 ; \
203	push eax ; \
204	mov ecx, this_ ; \
205	mov eax, [ecx] ; \
206	call [eax+funcOffset] ; \
207	}
208
209	#define CALL_THISCALL_1( resultName, thisPtr, funcOffset, param1 )\
210	void *this_ = (thisPtr); \
211	__asm { \
212	mov eax, param1 ; \
213	push eax ; \
214	mov ecx, this_ ; \
215	mov eax, [ecx] ; \
216	call [eax+funcOffset] ; \
217	mov resultName, eax ; \
218	}
219
220	#define CALL_THISCALL_1_DOUBLE( resultName, thisPtr, funcOffset, param1 )\
221	void *this_ = (thisPtr); \
222	void *doubleParamPtr_ (&param1); \
223	__asm { \
224	mov eax, doubleParamPtr_ ; \
225	push [eax+4] ; \
226	push [eax] ; \
227	mov ecx, this_ ; \
228	mov eax, [ecx] ; \
229	call [eax+funcOffset] ; \
230	mov resultName, eax ; \
231	}
232
233	#define CALL_THISCALL_2( resultName, thisPtr, funcOffset, param1, param2 )\
234	void *this_ = (thisPtr); \
235	__asm { \
236	mov eax, param2 ; \
237	push eax ; \
238	mov eax, param1 ; \
239	push eax ; \
240	mov ecx, this_ ; \
241	mov eax, [ecx] ; \
242	call [eax+funcOffset] ; \
243	mov resultName, eax ; \
244	}
245
246	#define CALL_THISCALL_4( resultName, thisPtr, funcOffset, param1, param2, param3, param4 )\
247	void *this_ = (thisPtr); \
248	__asm { \
249	mov eax, param4 ; \
250	push eax ; \
251	mov eax, param3 ; \
252	push eax ; \
253	mov eax, param2 ; \
254	push eax ; \
255	mov eax, param1 ; \
256	push eax ; \
257	mov ecx, this_ ; \
258	mov eax, [ecx] ; \
259	call [eax+funcOffset] ; \
260	mov resultName, eax ; \
261	}
262
263	#elif defined(__GNUC__)
264
265	#define CALL_THISCALL_0( resultName, thisPtr, funcOffset ) \
266	__asm__ __volatile__ ("movl (%1), %%edx\n\t" \
267	"call *"#funcOffset"(%%edx)\n\t" \
268	:"=a"(resultName) /* Output Operands */ \
269	:"c"(thisPtr) /* Input Operands */ \
270	: "%edx" /* Clobbered Registers */ \
271	); \
272
273	#define CALL_VOID_THISCALL_1( thisPtr, funcOffset, param1 ) \
274	__asm__ __volatile__ ("pushl %0\n\t" \
275	"movl (%1), %%edx\n\t" \
276	"call *"#funcOffset"(%%edx)\n\t" \
277	: /* Output Operands */ \
278	:"r"(param1), /* Input Operands */ \
279	"c"(thisPtr) \
280	: "%edx" /* Clobbered Registers */ \
281	); \
282
283	#define CALL_THISCALL_1( resultName, thisPtr, funcOffset, param1 ) \
284	__asm__ __volatile__ ("pushl %1\n\t" \
285	"movl (%2), %%edx\n\t" \
286	"call *"#funcOffset"(%%edx)\n\t" \
287	:"=a"(resultName) /* Output Operands */ \
288	:"r"(param1), /* Input Operands */ \
289	"c"(thisPtr) \
290	: "%edx" /* Clobbered Registers */ \
291	); \
292
293	#define CALL_THISCALL_1_DOUBLE( resultName, thisPtr, funcOffset, param1 ) \
294	do { \
295	double param1f64 = param1; /* Cast explicitly to double */ \
296	double param1f64Ptr = &param1f64; / Make pointer to address */ \
297	__asm__ __volatile__ ("pushl 4(%1)\n\t" \
298	"pushl (%1)\n\t" \
299	"movl (%2), %%edx\n\t" \
300	"call *"#funcOffset"(%%edx);\n\t" \
301	: "=a"(resultName) /* Output Operands */ \
302	: "r"(param1f64Ptr), /* Input Operands */ \
303	"c"(thisPtr), \
304	"m"(param1f64Ptr) / Using address */ \
305	: "%edx" /* Clobbered Registers */ \
306	); \
307	} while (0); \
308
309
310	#define CALL_THISCALL_2( resultName, thisPtr, funcOffset, param1, param2 ) \
311	__asm__ __volatile__ ("pushl %1\n\t" \
312	"pushl %2\n\t" \
313	"movl (%3), %%edx\n\t" \
314	"call *"#funcOffset"(%%edx)\n\t" \
315	:"=a"(resultName) /* Output Operands */ \
316	:"r"(param2), /* Input Operands */ \
317	"r"(param1), \
318	"c"(thisPtr) \
319	: "%edx" /* Clobbered Registers */ \
320	); \
321
322	#define CALL_THISCALL_4( resultName, thisPtr, funcOffset, param1, param2, param3, param4 )\
323	__asm__ __volatile__ ("pushl %1\n\t" \
324	"pushl %2\n\t" \
325	"pushl %3\n\t" \
326	"pushl %4\n\t" \
327	"movl (%5), %%edx\n\t" \
328	"call *"#funcOffset"(%%edx)\n\t" \
329	:"=a"(resultName) /* Output Operands */ \
330	:"r"(param4), /* Input Operands */ \
331	"r"(param3), \
332	"r"(param2), \
333	"r"(param1), \
334	"c"(thisPtr) \
335	: "%edx" /* Clobbered Registers */ \
336	); \
337
338	#endif
339
340	// Our static singleton instance.
341	IASIOThiscallResolver IASIOThiscallResolver::instance;
342
343	// Constructor called to initialize static Singleton instance above. Note that
344	// it is important not to clear that_ incase it has already been set by the call
345	// to placement new in ASIOInit().
346	IASIOThiscallResolver::IASIOThiscallResolver()
347	{
348	}
349
350	// Constructor called from ASIOInit() below
351	IASIOThiscallResolver::IASIOThiscallResolver(IASIO* that)
352	: that_( that )
353	{
354	}
355
356	// Implement IUnknown methods as assert(false). IASIOThiscallResolver is not
357	// really a COM object, just a wrapper which will work with the ASIO SDK.
358	// If you wanted to use ASIO without the SDK you might want to implement COM
359	// aggregation in these methods.
360	HRESULT STDMETHODCALLTYPE IASIOThiscallResolver::QueryInterface(REFIID riid, void **ppv)
361	{
362	(void)riid; // suppress unused variable warning
363
364	assert( false ); // this function should never be called by the ASIO SDK.
365
366	*ppv = NULL;
367	return E_NOINTERFACE;
368	}
369
370	ULONG STDMETHODCALLTYPE IASIOThiscallResolver::AddRef()
371	{
372	assert( false ); // this function should never be called by the ASIO SDK.
373
374	return 1;
375	}
376
377	ULONG STDMETHODCALLTYPE IASIOThiscallResolver::Release()
378	{
379	assert( false ); // this function should never be called by the ASIO SDK.
380
381	return 1;
382	}
383
384	// Implement the IASIO interface methods by performing the vptr manipulation
385	// described above then delegating to the real implementation.
386	ASIOBool IASIOThiscallResolver::init(void *sysHandle)
387	{
388	ASIOBool result;
389	CALL_THISCALL_1( result, that_, 12, sysHandle );
390	return result;
391	}
392
393	void IASIOThiscallResolver::getDriverName(char *name)
394	{
395	CALL_VOID_THISCALL_1( that_, 16, name );
396	}
397
398	long IASIOThiscallResolver::getDriverVersion()
399	{
400	ASIOBool result;
401	CALL_THISCALL_0( result, that_, 20 );
402	return result;
403	}
404
405	void IASIOThiscallResolver::getErrorMessage(char *string)
406	{
407	CALL_VOID_THISCALL_1( that_, 24, string );
408	}
409
410	ASIOError IASIOThiscallResolver::start()
411	{
412	ASIOBool result;
413	CALL_THISCALL_0( result, that_, 28 );
414	return result;
415	}
416
417	ASIOError IASIOThiscallResolver::stop()
418	{
419	ASIOBool result;
420	CALL_THISCALL_0( result, that_, 32 );
421	return result;
422	}
423
424	ASIOError IASIOThiscallResolver::getChannels(long numInputChannels, long numOutputChannels)
425	{
426	ASIOBool result;
427	CALL_THISCALL_2( result, that_, 36, numInputChannels, numOutputChannels );
428	return result;
429	}
430
431	ASIOError IASIOThiscallResolver::getLatencies(long inputLatency, long outputLatency)
432	{
433	ASIOBool result;
434	CALL_THISCALL_2( result, that_, 40, inputLatency, outputLatency );
435	return result;
436	}
437
438	ASIOError IASIOThiscallResolver::getBufferSize(long minSize, long maxSize,
439	long preferredSize, long granularity)
440	{
441	ASIOBool result;
442	CALL_THISCALL_4( result, that_, 44, minSize, maxSize, preferredSize, granularity );
443	return result;
444	}
445
446	ASIOError IASIOThiscallResolver::canSampleRate(ASIOSampleRate sampleRate)
447	{
448	ASIOBool result;
449	CALL_THISCALL_1_DOUBLE( result, that_, 48, sampleRate );
450	return result;
451	}
452
453	ASIOError IASIOThiscallResolver::getSampleRate(ASIOSampleRate *sampleRate)
454	{
455	ASIOBool result;
456	CALL_THISCALL_1( result, that_, 52, sampleRate );
457	return result;
458	}
459
460	ASIOError IASIOThiscallResolver::setSampleRate(ASIOSampleRate sampleRate)
461	{
462	ASIOBool result;
463	CALL_THISCALL_1_DOUBLE( result, that_, 56, sampleRate );
464	return result;
465	}
466
467	ASIOError IASIOThiscallResolver::getClockSources(ASIOClockSource clocks, long numSources)
468	{
469	ASIOBool result;
470	CALL_THISCALL_2( result, that_, 60, clocks, numSources );
471	return result;
472	}
473
474	ASIOError IASIOThiscallResolver::setClockSource(long reference)
475	{
476	ASIOBool result;
477	CALL_THISCALL_1( result, that_, 64, reference );
478	return result;
479	}
480
481	ASIOError IASIOThiscallResolver::getSamplePosition(ASIOSamples sPos, ASIOTimeStamp tStamp)
482	{
483	ASIOBool result;
484	CALL_THISCALL_2( result, that_, 68, sPos, tStamp );
485	return result;
486	}
487
488	ASIOError IASIOThiscallResolver::getChannelInfo(ASIOChannelInfo *info)
489	{
490	ASIOBool result;
491	CALL_THISCALL_1( result, that_, 72, info );
492	return result;
493	}
494
495	ASIOError IASIOThiscallResolver::createBuffers(ASIOBufferInfo *bufferInfos,
496	long numChannels, long bufferSize, ASIOCallbacks *callbacks)
497	{
498	ASIOBool result;
499	CALL_THISCALL_4( result, that_, 76, bufferInfos, numChannels, bufferSize, callbacks );
500	return result;
501	}
502
503	ASIOError IASIOThiscallResolver::disposeBuffers()
504	{
505	ASIOBool result;
506	CALL_THISCALL_0( result, that_, 80 );
507	return result;
508	}
509
510	ASIOError IASIOThiscallResolver::controlPanel()
511	{
512	ASIOBool result;
513	CALL_THISCALL_0( result, that_, 84 );
514	return result;
515	}
516
517	ASIOError IASIOThiscallResolver::future(long selector,void *opt)
518	{
519	ASIOBool result;
520	CALL_THISCALL_2( result, that_, 88, selector, opt );
521	return result;
522	}
523
524	ASIOError IASIOThiscallResolver::outputReady()
525	{
526	ASIOBool result;
527	CALL_THISCALL_0( result, that_, 92 );
528	return result;
529	}
530
531	// Implement our substitute ASIOInit() method
532	ASIOError IASIOThiscallResolver::ASIOInit(ASIODriverInfo *info)
533	{
534	// To ensure that our instance's vptr is correctly constructed, even if
535	// ASIOInit is called prior to main(), we explicitly call its constructor
536	// (potentially over the top of an existing instance). Note that this is
537	// pretty ugly, and is only safe because IASIOThiscallResolver has no
538	// destructor and contains no objects with destructors.
539	new((void*)&instance) IASIOThiscallResolver( theAsioDriver );
540
541	// Interpose between ASIO client code and the real driver.
542	theAsioDriver = &instance;
543
544	// Note that we never need to switch theAsioDriver back to point to the
545	// real driver because theAsioDriver is reset to zero in ASIOExit().
546
547	// Delegate to the real ASIOInit
548	return ::ASIOInit(info);
549	}
550
551	#endif /* !defined(_MSC_VER) */
552	#endif /* !defined(__WIN64__) */
553	#endif /* Win32 */