Hallo Delphi-Gemeinde,
ich arbeite zur Zeit an einer Software zur Ansteuerung einer
IP-Kamera über deine
DLL im Rahmen meines Studiums. Daraus ergibt sich für mich die Frage, ob ich mit Threads den Bildaufbau (TBitmap) beschleunigen kann. Genauer geht es hier um den parallelen Zugriff auf den Arbeitsspeicher.
Zur Erklärung:
Die
DLL ruft meine Callbackfunktion auf nachdem Sie die Bilddaten in den Arbeitsspeicher geschrieben hat. Dabei übergibt diese mir eine Referenz für ein Bild.
Delphi-Quellcode:
function TCamera.Callback(image: Pointer): Integer;
var
data: ^Byte;
begin
//Aufruf einer DLL-Funktion
//Nun hole ich mir für dieses Bild den Pointer auf den Arbeitsspeicher, wo die Bilddaten liegen.
//data als Var-Parameter übergeben
getImage(image, Pointer(data));
end;
Anschließend beschreibe ich das TBitmap, hier der wesentliche Code
Delphi-Quellcode:
type
TRGBTripleArray = ARRAY[WORD] OF TRGBTriple;
[..]
var
Row_c: ^TRGBTripleArray;
[..]
bitmap := TBitmap.Create;
bitmap.PixelFormat := pf24Bit;
for j:= 0 to Bitmap.Height-1 do
begin
Row_c := Bitmap.ScanLine[j];
for i:= 0 to bitmap.Width-1 do
begin
with Row_c[i] do
begin
rgbtRed:= data^;
Inc(data);
rgbtGreen := data^;
Inc(data);
rgbtBlue := data^;
Inc(data);
end;
end;
end;
image1.Picture.Bitmap.Assign(bitmap); //image1 = TImage
bitmap.free;
Nun der
dll noch mitteilen, dass ich bereit für das nächste Bild bin
setImage(image);
Jetzt wird die Callbackfunktion erneut aufgerufen.
Jetzt zur Frage:
1. Inwiefern kann ich durch Threads zur Optimierung beitragen?
Die Idee ist die, dass die TBitmap-Bearbeitung in einem eigenen Thread abläuft. Die Callbackfunktion beinhaltet also:
getImage(image, Pointer(data));
//Thread wird gestartet: Beschreibt TBitmap(Code: s.oben)
setImage(image);
Vorteil: Der Pointer auf die Bilddaten des nächsten Bildes liegt durchweg bereit. Hier wird also Ressource "
DLL" und Ressource "Arbeitsspeicher" gleichzeitig genutzt.
2. Ist es sinnvoll mehrere Threads mit den Bearbeiten des TBitmaps zu beauftragen?
Soll heißen sobald Pointer auf Bilddaten vorliegt übergebe diesen an einen "Thread-Pool".
Vorteil: Mehrere TBitmaps werden gleichzeitig beschrieben.
Gretchenfrage: "Bremsen" sie sich nicht gegenseitig aus, da der "Thread-Pool" auf der gleichen Ressource - den Arbeitsspeicher - arbeitet?
Mir ist klar, dass es im Grunde geht. Nur ist nicht die Frage ob es nebenläufig zu bearbeiten geht, sondern ob dadurch ein Performancegewinn erzielt werden kann.
Gruß und danke vorab.