Dynamisches Array oder Klasse als Array auslegen

[marabu]

Zumindest bei mir unter D7 besser so:

Delphi-Quellcode:

 csh: PRTLCriticalSection;

Grüße, marabu

[EWeiss]

Zitat:

Zitat von marabu

Zumindest bei mir unter D7 besser so:

Delphi-Quellcode:

 csh: PRTLCriticalSection;

Grüße, marabu

ja ! :oops:
habe in der Windows.pas nochmal nachgesehen meine Annahme konnte nicht stimmen.

Die alte

Delphi-Quellcode:

csH                       : RTL_CRITICAL_SECTION;

war aber auch nicht richtig.

Mit dieser bekam ich eine invalid typecast meldung, mit deiner vorgeschlagenen Meldung.
nach der änderung zu PRTLCriticalSection nimmt der compiler deine lösung an.

Nur jetzt ist csh := nil:
Hat also einen AV zur folge.

Muss ich nun einen pointer auf InitializeCriticalSection setzen?
Wie stelle ich das an das sich csh wieder mit Daten füllt.

grüße

[marabu]

Ich habe noch mal ganz zum Anfang zurück geblättert und festgestellt, dass csH in winampDSPinfo ursprünglich als TRTLCriticalSection verbaut war - also nix mit Pointer. Warum bist du davon abgekommen? Du kannst das ruhig so beibehalten.

Grüße, marabu

[EWeiss]

Zitat:

Zitat von marabu

Ich habe noch mal ganz zum Anfang zurück geblättert und festgestellt, dass csH in winampDSPinfo ursprünglich als TRTLCriticalSection verbaut war - also nix mit Pointer. Warum bist du davon abgekommen? Du kannst das ruhig so beibehalten.

Grüße, marabu

weil beim stopen des Plugin

Delphi-Quellcode:

// Stopt eingeladenes Winamp DSP Plugin (aber entlädt es nicht)
Procedure BASS_WADSP_Stop(plugin : HDSP); stdcall;
var
    winampDsp : WINAMPPLUGINPROPDSP;

begin
  winampDsp := GetDSP(plugin);
   if winampDsp <> nil then
     begin
      if winampDsp^.pDSP <> nil then
      begin
         BASS_WADSP_ChannelRemoveDSP(plugin);
         EnterCriticalSection(winampDsp^.csH);
         winampDsp^.pDSP^.Quit(winampDsp^.pDSP);
         winampDsp^.pDSP := nil;
         winampDsp^.module := -1;
         LeaveCriticalSection(winampDsp^.csH);
      end;
   end;
end;

die anwendung sich verabschiedet.
Das gleiche auch bei allen anderen Functionen welche EnterCriticalSection in anspruch nehmen.
Auch sieht im CCode jede zeile so aus.

Code:

EnterCriticalSection(&winampDsp->csH);

Das '&' ist kein Operator = @ wäre dann ein pointer.

Also alles wieder zurück ? Kein Problem.

grüß

[EWeiss]

Ich habs immer noch nicht begriffen.

Wie kann ich generell verhindern das winampDsp den falschen wert
zugewiesen bekommt?

gruß

[marabu]

Moin Emil,

wo geschieht denn die falsche Zuweisung?

Gruß

[EWeiss]

Zitat:

Zitat von marabu

Moin Emil,

wo geschieht denn die falsche Zuweisung?

Gruß

Guten Morgen Marabu ;)
Bin langsam am verzweifeln..
Finde die richtigen verbindungen irgendwie nicht.

Delphi-Quellcode:

EnterCriticalSection(winampDsp^.csH);

Funktioniert generell nicht.
Entweder bleibt die Anwendung hier hängen > läuft einfach nicht weiter
Oder es gibt ein AV.

Delphi-Quellcode:

// Befreit alle DSP Plugin Resourcen und die Bass-Library
Procedure BASS_WADSP_Free(); stdcall;
Var
  a: DWORD;

Begin

   for a := 0 to winampDSPcounter do

   Begin

      winampDsp := winamp_DSP[a];
      if winampDsp <> nil then
      begin
         if winampDsp^.handle <> 0 then
            BASS_WADSP_Stop(winampDsp^.handle);
         // clear the slot
         winamp_DSP[a] := nil;
         Destroy_Winamp_Window(winampDsp);
         FreeLibrary(winampDsp^.hDll);
//         DeleteCriticalSection(winampDsp^.csH);
         FreeMem(winampDsp);
      end;
   end;
   BASS_WADSP_PluginInfoFree();
end;

Einladen der Plugins funktioniert.
Das beenden nicht.
Dieser Counter winampDSPcounter ist immer 0.
dadurch werden mir falsche Werte von winamp_DSP[a] an winampDsp übergeben.
winampDsp ist zwar dann nicht NIL aber die Daten stimmen mit dem Plugin auch nicht überein.
Incrementiere ich den Counter so das er bei 1 anfängt stimmen die werte aber bei FreeMem gibt es auch einen AV.

Weiß nicht weiter habe alle erdenklichen kombinationen versucht.
Name vom Archiv ist falsch geschrieben ... mach dir nix draus. :-D

GRüße

[marabu]

Wie kann ich mir mal einen Gesamtüberblick verschaffen? Bin mittlerweile auch etwas orientierungslos. Testen kann ich nicht, aber einen code-walk-through kann ich dir anbieten, wenn du Geduld hast. Muss nebenher auch was arbeiten.

Grüße, marabu

[EWeiss]

Zitat:

Zitat von marabu

Wie kann ich mir mal einen Gesamtüberblick verschaffen? Bin mittlerweile auch etwas orientierungslos. Testen kann ich nicht, aber einen code-walk-through kann ich dir anbieten, wenn du Geduld hast. Muss nebenher auch was arbeiten.

Grüße, marabu

Ich habe Geduld über allermaßen.
Mußt du eigentlich schon bemerkt haben. :wink: :-D

Nur schade das du der einzigste bist der Hilfe anbietet.
Naja vielleicht wissen die anderen nicht wie sie helfen können. :cry: :-D

Habe es oben hochgeladen.

Grüße

[EWeiss]

Warum mache ich mir die ganze arbeit.

1. Nicht für mich sondern für die Allgemeinheit.
2. Schreibe an einen Multifunktionsfähigen Plugin welches als ausgangsbasis die BassLibrary benötigt.
3. Es unterstützt bisher vis(Winamp/Sonique),input,gen,dsp in verbindung mit Input-plugins.

Das problem bei der aktuellen DSP version sie kann nur 1 Plg zur gleichen zeit steuern.
Dann möchte ich gerne das die API die gleiche bleibt wie bei den Plugin welches ich übersetze.
Dadurch hat der User der den .NET ApiWrapper für Bass geschrieben hat nachher
bei seiner Hilfe-Anleitung weniger Arbeit.
Kann dann die gleiche benutzen wie bei den standallone Plugin von ihm.

Hier ein Pic!

[EWeiss]

Hier fängt die geschichte an.

Delphi-Quellcode:

// Initialisiert das BASS_WADSP add-on 
Function BASS_WADSP_Init(hwndMain: HWND): DWORD; stdcall;

begin
   mainhwnd := hwndMain;

  Result:= mainhwnd;
end;

Ist OK !!

Plugins werden eingeladen

Delphi-Quellcode:

 // Läd ein Winamp DSP Plugin und  übergibt das handle
 // Koordinaten und ein User Callback können übergeben werden
function BASS_WADSP_Load(const dspfile: PChar; x, y, Width, Height: integer;
                         proc: WINAMPWINPROC): HDSP; stdcall;

var
  winampDsp: WINAMPPLUGINPROPDSP;
  cnt: integer;

begin
  winampDsp := AllocMem(sizeof(WINAMPPLUGINPROPDSP));
  FillChar(winampDsp, 0, sizeof(winampDsp));

  Saved8087CW := Default8087CW;
  //FPU - Exceptions deaktivieren
  Set8087CW($133f);

  // Library laden
  // zuerst mit unicode versuchen
  winampDsp^.hDll := LoadLibraryW(PWideChar(dspfile));
  if (not winampDsp^.hDll) <> 0 then
  begin
    // ansonsten Ansi
    winampDsp^.hDll := LoadLibrary(dspfile);
  end;

  // Exceptions zurück auf Defaultwert
  Set8087CW(Saved8087CW);

  Result := 0;

  if winampDsp^.hDll <> 0 then
  begin
    FreeMem(winampDsp);

    pGetMod := GetProcAddress(winampDsp^.hDll, 'winampDSPGetHeader2');
    if pGetMod <> nil then
    begin
      // Fake Winamp Window erstellen
      if (Create_Winamp_Window(winampDsp, x, y, Width, Height, proc)) = True then
      begin
        cnt := 0;
        winampDsp^.pModule := pGetMod;
        if winampDsp^.pModule <> nil then
        begin
          // Schleife durchlaufen bis kein Modul mehr gefunden wurde
          repeat
            Inc(cnt);
          until winampDsp^.pModule^.getModule(cnt) = nil;
          // Anzahl der Module speichern
          winampDsp^.NumberOfModules := cnt;
          winampDsp^.module := -1;
          InitializeCriticalSection(winampDsp^.csh);
          // Addiere ein neues Winamp DSP Plugin
          AddDSP(winampDsp);
          // Übergebe das Handle
          Result := winampDsp^.handle
      end else
        // Bei Fehler Winamp Fake Window beenden
        Destroy_Winamp_Window(winampDsp);
    end else
      // Library freigeben
      FreeLibrary(winampDsp^.hDll);
    end
  end
end;

Ist OK !!

FakeWindow wird erstellt! Für jedes Plugin einzeln.

Delphi-Quellcode:

// Erstellt ein  Fake Winamp window
function Create_Winamp_Window(winampDsp: WINAMPPLUGINPROPDSP; x, y, width, height: integer; proc: WINAMPWINPROC): Boolean; stdcall;
var
  wndclass: WNDCLASSEX;
  dspCount : DWORD;
  AppClass : Pchar;

begin
  dspCount := GetActiveDSPs;

  if dspCount > 0 then
      begin
      AppClass := PChar(Format(Pchar('Winamp v1.x : %d'), [winampDSPcounter + 1]));
  end else
   AppClass := 'Winamp v1.x';

  Inst := GetModuleHandle(nil);

  with wndclass do
  begin
     cbSize        := sizeof(wndclass);
     style         := CS_PARENTDC or CS_VREDRAW;
     cbClsExtra    := 0;
     cbWndExtra    := 0;
     hInstance     := Inst;
     hIcon         := 0;
     hCursor       := LoadCursor(0, IDC_ARROW);
     hbrBackground := 0;
     lpszMenuName  := nil;
     lpszClassName := AppClass;
   if  proc = 0 then
      lpfnWndProc   := @WinampWndProc
   else
      lpfnWndProc   := @proc;
     hIconSm := 0;
  end;

   winampDsp^.DSP_Atom_Emu := RegisterClassEx(wndclass);
   if winampDsp^.DSP_Atom_Emu <> 0 then

   winampDsp^.DSP_Atom_Emu := CreateWindowEx(0,              // DWORD dwExStyle
                                                    AppClass,       // LPCTSTR lpClassName
                                            'Winamp 2.40',  // LPCTSTR lpWindowName
                                                    WS_POPUP,       // DWORD dwStyle
                                                    x,              // int x
                                            y,              // int y
                                            width,          // int nWidth
                                            height,         // int nHeight
                                                    mainhwnd,       // HWND hWndParent
                                            0,              // HMENU hMenu
                                            Inst,  //        // HINSTANCE hInstance
                                            nil);           // LPVOID lpParam

   if winampDsp^.DSP_Window_Emu = 0 then
    begin
      UnRegisterClass(PChar(WORD(winampDsp^.DSP_Atom_Emu)), Inst);
      MessageBox(mainhwnd, 'Unable to emulate Winamp Window!', 'BASS DSP Error!', MB_ICONEXCLAMATION or MB_ICONWARNING);
      Result := false
    end
  else
   Result := true;
end;

Ist OK!

Aus der Winproc wird die Funktion GetActiveDSPs aufgerufen welche
den Counter hochzählt und abhängig davon den ClassenNamen ändert

AppClass := PChar(Format(Pchar('Winamp v1.x : %d'), [winampDSPcounter + 1]));
damit nicht zwei die gleichen Windows erstellt werden.

Delphi-Quellcode:

function GetActiveDSPs(): DWORD; stdcall;
var
  a:   DWORD;
  cnt: DWORD;
  winampDSP: WINAMPPLUGINPROPDSP;

begin
  cnt := 0;

  if Winamp_DSP <> nil then

  for a := 0 to winampDSPcounter do
  begin
    winampDSP := Winamp_DSP[a];
    if winampDSP <> nil then
      Inc(cnt);
  end;
  Result := cnt;
end;

Das ist auch in Ornung!


Dann wir das gewählte Plugin addiert.

Delphi-Quellcode:

Procedure AddDSP(winampDsp: WINAMPPLUGINPROPDSP); stdcall;

var
  a: DWORD;

begin

  Winamp_DSP := DspPtrArray(winampDsp);

  for a := 0 to winampDSPcounter do
    if not Assigned(Winamp_DSP[a]) then
      Break;

  if a = winampDSPcounter then
  begin
    // Array nicht leer, füge ein neues hinzu
    ReallocMem(Winamp_DSP, (winampDSPcounter + 1) * SizeOf(WINAMPPLUGINPROPDSP));
    Dec(winampDSPcounter);
  end;
  Inc(winampDSPhandle);
  winampDsp^.handle := winampDSPhandle;
  // addiere ein Winamp DSP Plugin zum Array
  Winamp_DSP[a] := winampDsp;

end;

Scheint OK zu sein. Obwohl bisher noch nie in ReallocMem reingesprungen wurde.

Nun wird der Name des Moduls übergeben

Delphi-Quellcode:

// Returns the name of a loaded Winamp DSP plugin
function BASS_WADSP_GetName(plugin: HDSP): LPTSTR; stdcall;
Var
  strRet: PChar;
  winampDSP: WINAMPPLUGINPROPDSP;

begin
  strRet := nil;
  winampDsp := GetDSP(plugin);
   if winampDsp <> nil then
   begin
       strRet := winampDsp^.pModule^.description;
   end;
   Result := strRet;
end;

ist auch OK!

GetDSP übergibt den wert aus dem ArrayWinamp_DSP[a]

Delphi-Quellcode:

function GetDSP(handle: DWORD): WINAMPPLUGINPROPDSP;
var
  a: DWORD;

begin 
  if handle <> 0 then
    for a := 0 to Pred(winampDSPcounter) do
    begin 
      Result := Winamp_DSP[a];
      if Assigned(Result) and (Result^.handle = handle)
        then Exit;
    end;
  Result := nil;
end;

ist auch in Ordnung!

Dann wird das Plugin entladen und das nächste eingeladen falls vorhanden.

Delphi-Quellcode:

// Entlade das übergebene Winamp DSP Plugin
Procedure BASS_WADSP_FreeDSP(plugin: HDSP); stdcall ;
begin
   FreeDSP(plugin);
end;

So bis hier ist alles OK!

gruß

[marabu]

Emil, ich bin sehr müde, aber das hier erkenne ich, wenn ich deinen Beitrag #50 sequentiell durchgehe:

Delphi-Quellcode:

function BASS_WADSP_Load(const dspfile: PChar; x, y, Width, Height: integer;
                         proc: WINAMPWINPROC): HDSP; stdcall;
var
  winampDsp: WINAMPPLUGINPROPDSP;
  cnt: integer;
begin
// so holst du dir nur 4 Byte Speicher für einen Pointer:
//  winampDsp := AllocMem(sizeof(WINAMPPLUGINPROPDSP));  
// Besser so:
  winampDsp := AllocMem(sizeof(WINAMPPLUGINPROPDSP^));

// So löschst du den Zeiger genauso effektiv, als ob du ihn auf NIL setzt:
//  FillChar(winampDsp, 0, sizeof(winampDsp));
// Besser so:
  FillChar(winampDsp^, 0, sizeof(winampDsp^));
  // ...
end;

Du erkennst den Unterschied? Dann wirst du auch ähnliche Stellen in deinem Code erkennen, falls noch weitere solche Fehler drin stecken.

Grüße vom marabu

[EWeiss]

Zitat:

Zitat von marabu

Emil, ich bin sehr müde, aber das hier erkenne ich, wenn ich deinen Beitrag #50 sequentiell durchgehe:

Delphi-Quellcode:

function BASS_WADSP_Load(const dspfile: PChar; x, y, Width, Height: integer;
                         proc: WINAMPWINPROC): HDSP; stdcall;
var
  winampDsp: WINAMPPLUGINPROPDSP;
  cnt: integer;
begin
// so holst du dir nur 4 Byte Speicher für einen Pointer:
//  winampDsp := AllocMem(sizeof(WINAMPPLUGINPROPDSP));  
// Besser so:
  winampDsp := AllocMem(sizeof(WINAMPPLUGINPROPDSP^));

// So löschst du den Zeiger genauso effektiv, als ob du ihn auf NIL setzt:
//  FillChar(winampDsp, 0, sizeof(winampDsp));
// Besser so:
  FillChar(winampDsp^, 0, sizeof(winampDsp^));
  // ...
end;

Du erkennst den Unterschied? Dann wirst du auch ähnliche Stellen in deinem Code erkennen, falls noch weitere solche Fehler drin stecken.

Grüße vom marabu

Danke..
Werde es mir genau ansehen und vergleichen im Quelltext-
Dann ein gutes Nächtele man schreibt sich.

Gruß

[EWeiss]

Delphi-Quellcode:

Werde es mir genau ansehen und vergleichen im Quelltext-
Dann ein gutes Nächtele man schreibt sich.

Ich denke das Problem lokalisiert zu haben.
Wie angenommen liegt es immer noch an AddDSP

Der Lokale Zähler welcher die Plugins incrementiert? wird nicht hochgerechnet.
Ist der grund das mir überall falsche werte angezeigt werden.

Original

Code:

void AddDSP(WINAMPPLUGINPROPDSP *winampDsp)
{
   DWORD a;
   for (a=0;a<winampDSPcounter;a++)
        if (!winampDSP[a]) break;

   if (a==winampDSPcounter) 
   { 
      // no empty slot, so add a new one
      winampDSP = (WINAMPPLUGINPROPDSP**)realloc(winampDSP, (winampDSPcounter+1)*sizeof(WINAMPPLUGINPROPDSP*));
      winampDSPcounter++;
   }
   winampDsp->handle = ++winampDSPhandle;
   // insert the new Winamp DSP
   winampDSP[a] = winampDsp;
}

Dieser zähler winampDSPcounter++; wird nie angeprochen

Übersetzt

Delphi-Quellcode:

Procedure AddDSP(winampDsp: WINAMPPLUGINPROPDSP); stdcall;

var
  a: DWORD;

begin

  // Habe ich addiert weil bei 'if not Assigned(Winamp_DSP[a])' immer ein AV auftrat
  // Kann aber nicht stimmen da im C++ auch nicht enthalten.
  Winamp_DSP := DspPtrArray(winampDsp);

  for a := 0 to winampDSPcounter do
    // Wenn oben auskommentiert gibts hier einen AV
    if not Assigned(Winamp_DSP[a]) then
      Break;

  if a = winampDSPcounter then
  begin
    // Kein leerer Speicherbereich, einen neuen hinzufügen
    ReallocMem(Winamp_DSP, (winampDSPcounter + 1) * SizeOf(WINAMPPLUGINPROPDSP));
    // Bin nicht sicher ob DEC oder INC da dies ein Postfix-Operator in c++ ist:
    // Denke aber da hier nur ein Wert steht, er hochzählen soll.
    // Wird der zähler nicht verwendet funktioniert der ganze Code nicht
    // In fast jeder Function wird dieser mit a verglichen.
    Inc(winampDSPcounter);
  end;
  Inc(winampDSPhandle);
  winampDsp^.handle := winampDSPhandle;
  // addiere ein Winamp DSP Plugin zum Array (im neuangelegten leeren Speicherbereich)
  Winamp_DSP[a] := winampDsp;

end;

Im grunde geht es jetzt nur um diese eine Zeile.

Code:

if (!winampDSP[a]) break;

Delphi-Quellcode:

    if not Assigned(Winamp_DSP[a]) then
      Break;

Kann irgendwie nicht stimmen, weil so, wenn ich in Break hineinspringe, 'a' um eins hochgezählt wird.
'a = winampDSPcounter' kann also niemals eintreten. a wird immer um einen zähler höher sein.

Das Resultat ist das winampDSPcounter immer 0 ist.
Dies hat wiederum zur folge das ich keine richtigen werte im Speicher finde da sie nicht
an der richtigen position stehen und kein Speicherbereich dafür bereitgestellt wurde.
Auch die FakeWindows welche von dem Zähler abhängig sind werden nicht korrekt erstellt.

Delphi-Quellcode:

AppClass := PChar(Format(Pchar('Winamp v1.x : %d'), [winampDSPcounter + 1]));

Der KlassenName wird ja um den wert '%d' mit dem winampDSPcounter hochgezählt.

Grüße Emil

[marabu]

Guten Morgen Emil,

du hast Recht - die Prozedur AddDSP() ist fehlerhaft. Zuerst musst du die Initailsierung von winampDSPcounter sicher stellen:

Delphi-Quellcode:

// unit BassWaDSP;
var
  winampDSPcounter          : DWORD   = 0;

Dann müssen ein paar Änderungen an der Prozedur AddDSP() vorgenommen werden:

Delphi-Quellcode:

Procedure AddDSP(winampDsp: WINAMPPLUGINPROPDSP); stdcall;
var
  a: DWORD;
begin
  a := 0;
  // freien slot suchen
  while (a < winampDSPcounter) and Assigned(Winamp_DSP[a]) do
    Inc(a);

  if a = winampDSPcounter then
  // neuer slot wird gebraucht
  begin
    // array um ein Element vergrößern
    Inc(winampDSPcounter);
    ReallocMem(Winamp_DSP, winampDSPcounter * SizeOf(WINAMPPLUGINPROPDSP));
  end;

  Inc(winampDSPhandle);
  winampDsp^.handle := winampDSPhandle;

  // plugin an freier Stelle einfügen
  Winamp_DSP^[a] := winampDsp;
end;

Testen musst du.

Grüße

[EWeiss]

Guten Morgen .. mara ? oder bu ;)

Zitat:

du hast Recht - die Prozedur AddDSP() ist fehlerhaft. Zuerst musst du die Initailsierung von winampDSPcounter sicher stellen:

Springt nur einmal in

Delphi-Quellcode:

ReallocMem(Winamp_DSP, (winampDSPcounter + 1) * SizeOf(WINAMPPLUGINPROPDSP)); 
Inc(winampDSPcounter);

Nebenbei zum lernen.
War meine Annahme nicht richtig mit dem speicher?
Freier Slot nicht freier Speicherbereich.
Wird bei ReallocMem nicht der speicher verschoben damit das nächste Plugin dort eingebunden wird
sondern nur das array um ein Element vergrößert.

gruß

[marabu]

Hallo Emil,

ich hatte einen blöden Fehler in der Suchschleife. Ich habe ihn im Beitrag #55 korrigiert. Zu deiner Frage bezüglich ReallocMem(): Der Speicher wird auf seine neue Größe gebracht, der alte Inhalt wird automatisch beibehalten - zur Not per copy, falls kein inplace resizing möglich war. Der Zeiger muss call-by-reference sein, damit bei einer Verschiebung an eine andere Adresse der Zeiger aktualisiert werden kann. Der neue Speicherbereich wird nicht initialisiert.

Grüße

[EWeiss]

Zitat:

Zitat von marabu

Hallo Emil,

ich hatte einen blöden Fehler in der Suchschleife. Ich habe ihn im Beitrag #55 korrigiert. Zu deiner Frage bezüglich ReallocMem(): Der Speicher wird auf seine neue Größe gebracht, der alte Inhalt wird automatisch beibehalten - zur Not per copy, falls kein inplace resizing möglich war. Der Zeiger muss call-by-reference sein, damit bei einer Verschiebung an eine andere Adresse der Zeiger aktualisiert werden kann. Der neue Speicherbereich wird nicht initialisiert.

Grüße

Danke!
Wenn der Quelltext schon nicht läuft möchte ich zumindest was bei der ganzen Geschichte hier lernen.
Jetzt tritt ein neues Phänomen auf.

Die Fake Windows werden nicht mehr initialisiert.
Aber das löse ich selber!
Mit dem was ich bisher von dir gelernt habe.

An deiner neuen AddDSP liegt es aber nicht. :wink:

Grüße

[EWeiss]

Hier nochmal das komplette archiv.
Change ..
gruß