www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Any way to access a C++ DLL?

reply mike <vertex gmx.at> writes:
Hi!

Lot's of questions coming up ... but that's really important for me, if =
I  =

can't solve that I have to throw away over half a year of invested spare=
  =

time, so:

Is there any way to access a C++ DLL (precisely: a VST plugin - for thos=
e  =

who don't know: VST is a plugin API for virtual synthesizers, audio/midi=
  =

effects, etc.) from D?

I'm working on a VST host in D. I knew that VST plugins are written in  =

C++ but I somehow had in mind that the VST SDK just maps the C++ objects=
  =

to C functions ... now I found out that I was terribly wrong - a VST  =

plugin host obtains a pointer to a C++ object from the DLL's main and  =

calls that for processing. So ... is there a way to wrap that with a D  =

class?

Since I'm not really experienced with plugins and calling conventions an=
d  =

that ... my guess is that there's the vtbl somewhere stored in the DLL, =
 =

one can calculate entry points for every member of the class from that a=
nd  =

needs to possibly push a this ptr on the stack before calling the functi=
on  =

pointer. Is that correct and doable? With a little research I'm sure I c=
an  =

make it work, but I would like to ask the experts here if it's at all  =

possible or if I should rather think of something else.

-Mike

-- =

Erstellt mit Operas revolution=E4rem E-Mail-Modul: http://www.opera.com/=
mail/
Sep 06 2006
next sibling parent reply xs0 <xs0 xs0.com> writes:
mike wrote:
 Hi!
 
 Lot's of questions coming up ... but that's really important for me, if 
 I can't solve that I have to throw away over half a year of invested 
 spare time, so:
 
 Is there any way to access a C++ DLL (precisely: a VST plugin - for 
 those who don't know: VST is a plugin API for virtual synthesizers, 
 audio/midi effects, etc.) from D?
 
 I'm working on a VST host in D. I knew that VST plugins are written in 
 C++ but I somehow had in mind that the VST SDK just maps the C++ objects 
 to C functions ... now I found out that I was terribly wrong - a VST 
 plugin host obtains a pointer to a C++ object from the DLL's main and 
 calls that for processing. So ... is there a way to wrap that with a D 
 class?
 
 Since I'm not really experienced with plugins and calling conventions 
 and that ... my guess is that there's the vtbl somewhere stored in the 
 DLL, one can calculate entry points for every member of the class from 
 that and needs to possibly push a this ptr on the stack before calling 
 the function pointer. Is that correct and doable? With a little research 
 I'm sure I can make it work, but I would like to ask the experts here if 
 it's at all possible or if I should rather think of something else.

You can't call C++ code directly from D. However, you can call C code, meaning you can write a bunch of C functions that call C++ methods, and use that from D. something like C++: struct FooBoo { FooBoo() { ... } void boo(int a); } extern "C" { void* FooBoo_create() { return (void*) new FooBoo(); } void FooBoo_boo(void* obj, int a) { ((FooBoo*)obj)->boo(a); } void FooBoo_delete(void *obj) { delete ((FooBoo*)obj); } } D: extern(C) FooBoo_create(); extern(C) FooBoo_boo(void* obj, int a); extern(C) FooBoo_delete(void *obj); class FooBoo { void* obj; public this() { obj = FooBoo_create(); } public boo(int a) { FooBoo_boo(obj, a); } ~this() { FooBoo_delete(obj); obj = null; } } xs0
Sep 06 2006
parent mike <vertex gmx.at> writes:
Am 06.09.2006, 13:12 Uhr, schrieb xs0 <xs0 xs0.com>:

 You can't call C++ code directly from D. However, you can call C code,=

 meaning you can write a bunch of C functions that call C++ methods, an=

 use that from D.

 something like

 C++:

 struct FooBoo
 {
      FooBoo() { ... }
      void boo(int a);
 }

 extern "C" {
 void* FooBoo_create()
 {
      return (void*) new FooBoo();
 }

 void FooBoo_boo(void* obj, int a)
 {
      ((FooBoo*)obj)->boo(a);
 }

 void FooBoo_delete(void *obj)
 {
      delete ((FooBoo*)obj);
 }
 }


 D:

 extern(C) FooBoo_create();
 extern(C) FooBoo_boo(void* obj, int a);
 extern(C) FooBoo_delete(void *obj);

 class FooBoo
 {
      void* obj;
      public this() {
          obj =3D FooBoo_create();
      }

      public boo(int a) {
          FooBoo_boo(obj, a);
      }

      ~this() {
          FooBoo_delete(obj); obj =3D null;
      }
 }


 xs0

Stupid me! Never thought about that (why do it the easy way when you can= = do it the hard way ... hehe). Thanks a lot! -Mike -- = Erstellt mit Operas revolution=E4rem E-Mail-Modul: http://www.opera.com/= mail/
Sep 06 2006
prev sibling parent reply Steve Horne <stephenwantshornenospam100 aol.com> writes:
On Wed, 06 Sep 2006 13:03:40 +0200, mike <vertex gmx.at> wrote:

Is there any way to access a C++ DLL (precisely: a VST plugin - for those  
who don't know: VST is a plugin API for virtual synthesizers, audio/midi  
effects, etc.) from D?

I'm a newb, but I can still say yes - in principle. Worst case, you write an adaptor lib in C++ which provides a C level API. D can easily call that. On the C level, you see functions that take 'handles' as parameters. It's a lot like the Windows APIs - those window and device context handles are actually object pointers and, very likely, those C-like function calls use an underlying C++-style virtual function call in order to resolve what kind of window/device context/whatever they are dealing with. I haven't dealt with VST plugins, but for the main plugin mechanism I have used, there is a single exported function in the DLL. This is normally accessed through GetProcAddress, and when called it provides an object which is used as a kind of 'factory' for API objects. Mapping all of that to a C-compatible adaptor lib would be a pain, but not difficult as such. Just hassle. You could, of course, use SWIG. AFAIK it can't generate D wrappers yet, but it can generate an XML description of a C++ API which you could then translate to a D wrapper using XSLT. Of course this might take some time and fiddling around. Far better case - perhaps VST uses COM? After all, there aren't any big overheads to using COM, providing the interfaces are provided by a local DLL. All basic COM does is allow an executable or DLL to call create objects and call interfaces defined in another DLL. The calls are just C++-style virtual function calls through an interface object pointer. I believe D has built-in support for COM, making it easier to program COM in D than in C++, though I haven't used it. -- Remove 'wants' and 'nospam' from e-mail.
Sep 06 2006
parent mike <vertex gmx.at> writes:
Thanks!

I'll go the wrapper route (no COM for VST). I need to translate a lot of=
  =

enums by hand, should mostly be copy/paste anyway.

-Mike

Am 06.09.2006, 13:28 Uhr, schrieb Steve Horne  =

<stephenwantshornenospam100 aol.com>:

 On Wed, 06 Sep 2006 13:03:40 +0200, mike <vertex gmx.at> wrote:

 Is there any way to access a C++ DLL (precisely: a VST plugin - for  =


 those
 who don't know: VST is a plugin API for virtual synthesizers, audio/m=


 effects, etc.) from D?

I'm a newb, but I can still say yes - in principle. Worst case, you write an adaptor lib in C++ which provides a C level API. D can easily call that. On the C level, you see functions that take 'handles' as parameters. It's a lot like the Windows APIs - those window and device context handles are actually object pointers and, very likely, those C-like function calls use an underlying C++-style virtual function call in order to resolve what kind of window/device context/whatever they are dealing with. I haven't dealt with VST plugins, but for the main plugin mechanism I have used, there is a single exported function in the DLL. This is normally accessed through GetProcAddress, and when called it provides an object which is used as a kind of 'factory' for API objects. Mapping all of that to a C-compatible adaptor lib would be a pain, but=

 not difficult as such. Just hassle.

 You could, of course, use SWIG. AFAIK it can't generate D wrappers
 yet, but it can generate an XML description of a C++ API which you
 could then translate to a D wrapper using XSLT. Of course this might
 take some time and fiddling around.


 Far better case - perhaps VST uses COM? After all, there aren't any
 big overheads to using COM, providing the interfaces are provided by a=

 local DLL. All basic COM does is allow an executable or DLL to call
 create objects and call interfaces defined in another DLL. The calls
 are just C++-style virtual function calls through an interface object
 pointer.

 I believe D has built-in support for COM, making it easier to program
 COM in D than in C++, though I haven't used it.

-- = Erstellt mit Operas revolution=E4rem E-Mail-Modul: http://www.opera.com/= mail/
Sep 06 2006