*.lib Dateien in Delphi nutzen

[Horst0815]

Da ich zur zeit mit kaputten Bein mein Tag auf dem Sofa friste wollte ich mich mal an einen Player für v2m-Module versuchen.

Cpp obj liegen vor (aus Lib extrahiert)

verwendet werden die in Cpp so

Code:

  /*************************************************************************************/
  /**                                                                                 **/
  /** DirectSound output code                                                         **/
  /**                                                                                 **/
  /*************************************************************************************/

  // your rendering callback function has to look this way:
  // parm: pointer you specified with dsInit
  // buf: pointer to interleved stereo float destination buffer (1.0=0dB)
  // len: length of buffer in samples (!)
  typedef void (__stdcall DSIOCALLBACK)(void *parm, float *buf, unsigned long len);

  // initializes DirectSound output.
  // callback: your render callback function
  // parm: a pointer that'll be supplied to the function on every call
  // hWnd: window handle of your application (GetForegroundWindow() works quite well :)
  unsigned long __stdcall dsInit(DSIOCALLBACK *callback, void *parm, void *hWnd);

  // shuts down DirectSound output
  void __stdcall dsClose();

  // gets sample-exact and latency compensated current play position
  signed long __stdcall dsGetCurSmp();

  // sets player volume (default is 1.0)
  void __stdcall dsSetVolume(float vol);

  // forces rendering thread to update. On single-core CPUs it's a good idea to
  // call this once per frame (improves A/V sync and reduces any stuttering), 
  // with more than one CPU it's pretty much useless.
  void __stdcall dsTick();

  // lock and unlock the sound thread's thread sync lock. If you want to modify
  // any of your sound variables outside the render thread, encapsulate that part
  // of code in between these two functions.
  void __stdcall dsLock();
  void __stdcall dsUnlock();

  /*************************************************************************************/
  /**                                                                                 **/
  /** Synthesizer interface                                                           **/
  /**                                                                                 **/
  /*************************************************************************************/

  // returns size of work memory in bytes. Per synthesizer instance reserve at least
  // this amount of memory and supply it as the "pthis" parameter of all other functions
  // Note: If you need only one static instance, 3 Megabytes are a good bet.
  unsigned int __stdcall synthGetSize();

  // inits synthesizer instance.
  // pthis     : pointer to work mem
  // patchmap  : pointer to patch data
  // samplerate: output sample rate (44100-192000 Hz), use 44100 when playing with dsio
  void __stdcall synthInit(void *pthis, const void *patchmap, int samplerate=44100);

  // inits global parameters
  // pthis: pointer to work mem
  // ptr  : pointer to global parameters
  void __stdcall synthSetGlobals(void *pthis, const void *ptr);

  // inits speech synthesizer texts
  // pthis: pointer to work mem
  // ptr  : pointer to text array
  void __stdcall synthSetLyrics(void *pthis, const char **ptr);

  // renders synth output to destination buffer
  // pthis: pointer to work mem
  // buf  : pointer to interleaved float stereo out buffer
  // smp  : number of samples to render
  // buf2 : if this is specified, the synth will render the left and right channel into
  //        two mono float buffers at buf and buf2 instead of one interleaved buffer
  // add  : if this is specified, the synth will add its output to the destination
  //        buffer instead of replacing its contents
  void __stdcall synthRender(void *pthis, void *buf, int smp, void *buf2=0, int add=0);

  // pipes a stream of MIDI commands to the synthesizer
  // pthis: pointer to work mem
  // ptr  : pointer to buffer with MIDI data to process.
  //        NOTE: The buffer MUST end with a 0xfd byte
  void __stdcall synthProcessMIDI(void *pthis, const void *ptr);

  // sets operation mode of VU meters
  // pthis: pointer to work mem
  // mode : 0 for peak meters, 1 for RMS meters
  void __stdcall synthSetVUMode(void *pthis, int mode); // 0: peak, 1: rms

  // retrieves VU meter data for a channel
  // pthis: pointer to work mem
  // ch   : channel to retrieve (0..15)
  // l    : pointer to float variable where left VU is stored
  // r    : pointer to float variable where right VU is stored
  void __stdcall synthGetChannelVU(void *pthis, int ch, float *l, float *r); // ch: 0..15

  // retrieves master VU meter
  // pthis: pointer to work mem
  // l    : pointer to float variable where left VU is stored
  // r    : pointer to float variable where right VU is stored
  void __stdcall synthGetMainVU(void *pthis, float *l, float *r);

#ifdef __cplusplus
}
#endif

#endif

was ich so übersetzt hab

Delphi-Quellcode:

var
  Form1: TForm1;
{$L dsio.obj}
// DirectSound output code                                                        **/
  // your rendering callback function has to look this way:
  // parm: pointer you specified with dsInit
  // buf: pointer to interleved stereo float destination buffer (1.0=0dB)
  // len: length of buffer in samples (!)
type
  TDSIOCALLBACK = Procedure(parm : Pointer; buf : PExtended; len : Cardinal);

// initializes DirectSound output.                                                        **/
  // callback: your render callback function
  // parm: a pointer that'll be supplied to the function on every call
  // hWnd: window handle of your application (GetForegroundWindow() works quite well :)
Function dsInit(Callback : TDSIOCALLBACK; parm: Pointer;Wnd : HWnd): Cardinal;  cdecl; external;
  // shuts down DirectSound output
Procedure dsClose; stdcall; external;
  // gets sample-exact and latency compensated current play position
Function dsGetCurSmp: Integer; stdcall; external;
  // sets player volume (default is 1.0)
Procedure dsSetVolume(vol: Extended); stdcall; external;
  // forces rendering thread to update. On single-core CPUs it's a good idea to
  // call this once per frame (improves A/V sync and reduces any stuttering),
  // with more than one CPU it's pretty much useless.
Procedure dsTick; stdcall; external;
  // lock and unlock the sound thread's thread sync lock. If you want to modify
  // any of your sound variables outside the render thread, encapsulate that part
  // of code in between these two functions.
Procedure dsLock; stdcall; external;
Procedure dsUnlock; stdcall; external;

{$L ronan.obj}
Procedure ronanCBInit; stdcall; external;
Procedure ronanCBTick; stdcall; external;
Procedure ronanCBNoteOn; stdcall; external;
Procedure ronanCBNoteOff; stdcall; external;
Procedure ronanCBSetCtl; stdcall; external;
Procedure ronanCBProcess; stdcall; external;
Procedure ronanCBSetCtl; stdcall; external;
{$L synth2.obj}
// Synthesizer interface                                                           **/
  // returns size of work memory in bytes. Per synthesizer instance reserve at least
  // this amount of memory and supply it as the "pthis" parameter of all other functions
  // Note: If you need only one static instance, 3 Megabytes are a good bet.
  Function synthGetSizene: Word; external;
  // inits synthesizer instance.
  // pthis     : pointer to work mem
  // patchmap  : pointer to patch data
  // samplerate: output sample rate (44100-192000 Hz), use 44100 when playing with dsio
  Procedure synthInitneu(pthis: Pointer; Const patchmap: Pointer; samplerate: Integer = 44100); external;
  // inits global parameters
  // pthis: pointer to work mem
  // ptr  : pointer to global parameters
  Procedure synthSetGlobalsne(pthis: Pointer; Const ptr: Pointer); external;
  // inits speech synthesizer texts
  // pthis: pointer to work mem
  // ptr  : pointer to text array
  Procedure synthSetLyrics(pthis: Pointer; Const ptr: PChar); external;
//  // renders synth output to destination buffer
//  // pthis: pointer to work mem
//  // buf  : pointer to interleaved float stereo out buffer
//  // smp  : number of samples to render
//  // buf2 : if this is specified, the synth will render the left and right channel into
//  //        two mono float buffers at buf and buf2 instead of one interleaved buffer
//  // add  : if this is specified, the synth will add its output to the destination
//  //        buffer instead of replacing its contents
  Procedure synthRenderneu(pthis, buf: Pointer; smp: Integer; buf2: Pointer = nil; add: Integer = 0); external;
  // pipes a stream of MIDI commands to the synthesizer
  // pthis: pointer to work mem
  // ptr  : pointer to buffer with MIDI data to process.
  //        NOTE: The buffer MUST end with a 0xfd byte
  Procedure synthProcessMIDIne(pthis: Pointer; Const ptr: Pointer); external;
  // sets operation mode of VU meters
  // pthis: pointer to work mem
  // mode : 0 for peak meters, 1 for RMS meters
  Procedure synthSetVUModene(pthis: Pointer;  mode: Integer); external;// 0: peak, 1: rms
  // retrieves VU meter data for a channel
  // pthis: pointer to work mem
  // ch   : channel to retrieve (0..15)
  // l    : pointer to float variable where left VU is stored
  // r    : pointer to float variable where right VU is stored
  Procedure synthGetChannelVUneu(pthis: Pointer;ch : Integer; l,r: PExtended); external;// ch: 0..15
  // retrieves master VU meter
  // pthis: pointer to work mem
  // l    : pointer to float variable where left VU is stored
  // r    : pointer to float variable where right VU is stored
  Procedure _synthGetMainVU(pthis: Pointer;  l,r: PExtended); external;

//Unused
//Procedure synthProcessMIDI(pthis: Pointer; Const ptr: Pointer); external;
////  extern void __stdcall synthSetSampler(void *pthis, const void *bankinfo, const void *samples);
//Procedure synthGetPoly(pthis, dest: Pointer); external;
//Procedure synthGetPgm(pthis, dest: Pointer); external;
////   extern void __stdcall synthGetLD(void *pthis, float *l, float *r);

was zu

Zitat:

[dcc32 Warnung] main.pas(68): W1011 Text hinter dem abschließenden 'END.' - wird vom Compiler ignoriert
[dcc32 Fehler] main.pas(28): E2065 Ungenügende Forward- oder External-Deklaration: 'dsInit'
[dcc32 Fehler] main.pas(29): E2065 Ungenügende Forward- oder External-Deklaration: 'dsClose'
[dcc32 Fehler] main.pas(30): E2065 Ungenügende Forward- oder External-Deklaration: 'dsGetCurSmp'
[dcc32 Fehler] main.pas(31): E2065 Ungenügende Forward- oder External-Deklaration: 'dsSetVolume'
[dcc32 Fehler] main.pas(32): E2065 Ungenügende Forward- oder External-Deklaration: 'dsTick'
[dcc32 Fehler] main.pas(33): E2065 Ungenügende Forward- oder External-Deklaration: 'dsLock'
[dcc32 Fehler] main.pas(34): E2065 Ungenügende Forward- oder External-Deklaration: 'dsUnlock'
[dcc32 Fehler] main.pas(39): E2065 Ungenügende Forward- oder External-Deklaration: 'synthGetSize'
[dcc32 Fehler] main.pas(40): E2065 Ungenügende Forward- oder External-Deklaration: 'synthIn'
[dcc32 Fehler] main.pas(41): E2065 Ungenügende Forward- oder External-Deklaration: 'synthRender'
[dcc32 Fehler] main.pas(42): E2065 Ungenügende Forward- oder External-Deklaration: 'synthProcessMIDI'
[dcc32 Fehler] main.pas(43): E2065 Ungenügende Forward- oder External-Deklaration: 'synthSetGlobals'
[dcc32 Fehler] main.pas(54): E2065 Ungenügende Forward- oder External-Deklaration: 'synthGetPoly'
[dcc32 Fehler] main.pas(55): E2065 Ungenügende Forward- oder External-Deklaration: 'synthGetPgm'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_CreateThread@24'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_WaitForSingleObject@8'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_SetThreadPriority@8'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_InitializeCriticalSection@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_EnterCriticalSection@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_LeaveCriticalSection@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_DeleteCriticalSection@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_DirectSoundCreate@12'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_CreateEventA@16'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_CloseHandle@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_SetEvent@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBInit@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBTick@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBNoteOn@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBNoteOff@4'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBSetCtl@12'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBProcess@12'
[dcc32 Fehler] main.pas(174): E2065 Ungenügende Forward- oder External-Deklaration: '_ronanCBSetSR@8'
[dcc32 Fataler Fehler] Play.dpr(5): F2063 Verwendete Unit 'main.pas' kann nicht compiliert werden
Misslungen
Verstrichene Zeit: 00:00:00.2

wandel ich die lib mit Coff2OMF um erhalte ich

Zitat:

[dcc32 Fehler] main.pas(59): E2045 Falsches Objektdateiformat: 'C:\Users\Harry Pothead\Desktop\libv2_1.5\dsio.obj'

somit sollte das Format ja erstmal stimmen

Edit: die Umgewandelt lib ist leer also scheint coff2lib hier fehler zu machen

Hat jemand eine Idee?

[Zacherl]

Ich nehme an das

Code:

#ifdef __cplusplus
}
#endif

gehört zu einem

Code:

#ifdef __cplusplus
extern "C" {
#endif

Block?

Falls nicht, könnte das Name Mangeling dein Problem sein.

Die mit _ geprefixten Funktionen wirst du in deiner Unit manuell deklarieren bzw. auf die entsprechenden APIs weiterleiten müssen, schätze ich.

BTW: Wusste gar nicht, dass Delphi jetzt direkt .lib Files nutzen kann. Habe früher immer das hier verwendet, um die .obj Dateien zu extrahieren:
https://msdn.microsoft.com/en-us/library/889z8z58.aspx

[Horst0815]

Also es liegt in der Tat am Coff2OMF Utility welches fast leere Dateien erstelltund in Delphi können Funktionen nunmal nicht so heissen _ronanCBProcess@12

[Zacherl]

Das @12 dahinter scheint eine Art von Mangeling zu sein. Sieht aus wie die Anzahl der Parameter * 4 (also die Anzahl an Bytes, um die der Stack Pointer nach dem Return wieder verringert werden muss).

Hast du mal mit der LIB.EXE aus meinem Link probiert die OBJs zu extrahieren?

[Horst0815]

ja diese 3

{$L dsio.obj}
{$L ronan.obj}
{$L synth.obj}
die *.lib hatte ich ja auskommentiert mit dieser kann der Compiler ja nix anfangen
//{$L dsound.lib}

[Horst0815]

Jemand noch irgendeine Idee wie ich die *.obj nutzen kann?

[CarstenB]

Ich hatte letztens in der Firma ein ähnliches Problem und bin auch mit diversen Konvertierungsversuchen gescheitert.

Allerdings kann Delphi seit spätestens XE2 auch COFF dazulinken.

Die führenden "_" können noch zu Verwirrung führen, evtl. kann da "-fno-leading-underscore" beim "C"-Übersetzen etwas helfen. Ich hab sie aber letztenendes dringelassen - so sieht man gleich, dass da was aus der "C"-Ecke aufgerufen wird.

[DualCoreCpu]

Ich habe das hier:
http://www.agner.org/optimize/#objconv

Objconv kann .lib Dateien sowohl nach coff .o als auch nach omf .obj konvertieren.

Danach halt testen ob das Linken klappt.

[delphifan2004]

Ich habe derzeit das gleiche Problem nur mit Freepascal.

Ich erhalte den Compilerfehler:

Error: Undefined Symbol _MeineFunktion

Wenn ich nun aber die Funktion in der Pascal Interface Unit mit UNterstrich schreibe, ist die Funktion ohne Unterstrich plötzlich das "Undefined Symbol".

Wie kann ich nun erreichen, dass Freepascal die Funktion akzeptiert?

Zitat von Zacherl:

Die mit _ geprefixten Funktionen wirst du in deiner Unit manuell deklarieren bzw. auf die entsprechenden APIs weiterleiten müssen, schätze ich.

Aber wie mache ich das? Wenn ich, wie schon gesagt, in der Pascal Interface Unit den Unterstrich einfach davor setze, meckert der Compiler über die Funktion ohne Unterstrich.

Gibt es da eine Compilereinstellung, die das Problem löst. Bei mir, wie gesagt Freepascal, nicht Delphi. Freepascal Version 3.0.

[schöni]

Ist die Problematik so zu verstehen, dass man die C/C++ Bibliothek schneller per Hand in Pascal konvertiert hat, als sich mit dem Linken der C/C++ Bibliothek abzuquälen?

Oder die C/C++ Bibliotheken selbst ohne bcc- oder GCC Erfahrung schneller in passendem Format mit passenden Konventionen neu übersetzt hat?

Dann prost Mahlzeit!