Also... Falls es nicht um eine exorbitant hohe Nutzerzahl geht und wir nur von einem geschlossenen, internen Netzwerk reden... Pack doch einfach immer die aktuellste EXE in eine Netzwerkfreigabe und erstelle bei den Anwendern nur eine direkte Verknüpfung auf diese Datei. Wenn du dann die Datei auf dem Server aktualisierst, führen alle Nutzer automatisch diese neue Datei aus.
Beiträge von chesstiger
-
-
Alternativ kann man auch was ohne Dateien mit TCP und Singleton bauen.
-
Aufruf von was?
Was genau hast du vor? Klingt nämlich wirklich etwas blöd, vielleicht kann man das ja noch schöner lösen.
-
Also... Generell sind Magic Numbers erstmal schlecht. Per se lässt sich ein Skript mit sprechenden Konstanten wesentlich schöner lesen. Allerdings kann es u.U. einfach angenehmer sein, direkt die Zahl zu schreiben. Und mit einigen Jahren Programmiererfahrung (besser: AutoIt- und Win32-Erfahrung) _weiß_ man halt einfach etliche Konstanten auswendig. Die bereits genannte -3 für GUI_EVENT_CLOSE ist fast jedem bekannt und wenn nicht durch den Kontext trotzdem schnell zuordbar. Da ist das in Ordnung, finde ich.
Und ehrlich gesagt gibt es auch einige Bereiche, die in AutoIt nicht durch Standard-Konstanten abgedeckt sind. Die meisten Errorcodes bspw. haben keine äquivalente Konstante. Oder -1 für das letzte Control bei GUI-Befehlen. Ist streng genommen auch eine Magic Number.
Zusammengefasst finde ich, dass man in vernünftigen Mengen durchaus Literale statt Konstanten verwenden kann. Solange man nicht die Übersicht verliert.
-
Huhu!
Irgendwie überfällt mich immer im Januar die Lust, etwas an diesem Stück Software zu machen. Daher ist jetzt das "schöne" Definieren von Strukturen dazugekommen. Mich nervt es immer ziemlich, Strukturen als Strings schreiben zu müssen. Das wird irgendwie schnell unübersichtlich, finde ich. Denkbar wäre noch ein GetAddress-Operator (also statt DllStructGetPtr($tMyStruct) ein ByRef $tMyStruct oder so)...
Kurzes Beispiel (aus der README):
Code
Alles anzeigenBeginStruct point_t int x int y EndStruct Local Struct point_t $tPointA, $tPointB $tPointA.x = 1 $tPointA.y = 2 $tPointB.x = 6 $tPointB.y = 3 ConsoleWrite("Distance: " & getDist($tPointA, $tPointB) & @CRLF) Func getDist($tA, $tB) Return Sqrt(($tA.x - $tB.x)^2 + ($tA.y - $tB.y)^2) EndFuncAlles wie immer im Repo!
-
alpines Du musst nach dem BitAnd auf Gleichheit mit $GUI_CHECKED prüfen. Sonst reicht ein gemeinsames Bit von aktuellem Status und $GUI_CHECKED für das Auslösen der Bedingung.
-
Das ist etwas tricky. Was ähnliches habe ich schon mal geschrieben. Das Problem dabei ist, von allen Fenstern ein Screenshot zu erstellen. Eigentlich kann man von minimierten Fenstern keinen Screenshot erstellen, dafür bedarf es eines kleinen Tricks und relativ viel WinAPI-Wissen. Dafür habe ich mir aber schon vor Jahren eine kleine UDF geschrieben.
Genau wie für das Auflisten aller Fenster eines Prozesses, gefiltert nach Klassennamen. Ich hab daraus mal fix ein Beispiel für Mozilla Firefox gebastelt:
C
Alles anzeigen#include <GDIPlus.au3> #include <WindowsConstants.au3> #include <WinAPI.au3> #include <WinAPIProc.au3> #include <WinAPIDiag.au3> #include <GDIPlus.au3> #include <Math.au3> ;prevent autoit BUG DllCall("user32.dll", "bool", "SetProcessDPIAware") Opt("MustDeclareVars", True) _GDIPlus_Startup() Global $ahCaptures[4] Global $hMainWnd = GUICreate("Browser Screen Preview", 600, 400) Global $hGfx = _GDIPlus_GraphicsCreateFromHWND($hMainWnd) Global $hBmp = _GDIPlus_BitmapCreateFromGraphics(600, 400, $hGfx) Global $hBuf = _GDIPlus_ImageGetGraphicsContext($hBmp) ;register handlers OnAutoItExitRegister(exitProgram) AdlibRegister(updateWindowPreviews, 2000) updateWindowPreviews() ;initial call GUISetState() While True Switch GUIGetMsg() Case -3 Exit EndSwitch _GDIPlus_GraphicsClear($hBuf, 0xffffffff) ;white background If $ahCaptures[0] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[0], 0, 0, 300, 200) If $ahCaptures[1] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[1], 300, 0, 300, 200) If $ahCaptures[2] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[2], 0, 200, 300, 200) If $ahCaptures[3] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[3], 300, 200, 300, 200) _GDIPlus_GraphicsDrawImage($hGfx, $hBmp, 0, 0) WEnd Func updateWindowPreviews() Local $aWndList, $iWinCount, $hWnd, $i $aWndList = getProcessWindows("firefox.exe", "^MozillaWindowClass$") $iWinCount = _Min(4, UBound($aWndList)) ;maximum of four windows For $i = 0 To 3 $ahCaptures[$i] = Null Next For $i = 0 To $iWinCount - 1 $hWnd = $aWndList[$i] $ahCaptures[$i] = captureWindow($hWnd) $ahCaptures[$i] = _GDIPlus_BitmapCreateFromHBITMAP($ahCaptures[$i]) ;gdiplus workaround Next EndFunc ;==>updateWindowPreviews Func exitProgram() ;dispose gdi resources _GDIPlus_GraphicsDispose($hBuf) _GDIPlus_BitmapDispose($hBmp) _GDIPlus_GraphicsDispose($hGfx) _GDIPlus_Shutdown() ;make sure to re-enable window animations setMinAnimation(True) EndFunc ;==>exitProgram ; - - - MULTI PURPOSE FUNCTIONS - - - Func getProcessWindows($sWantedProcess, $sClassFilter = ".*") ;by chesstiger Local $iPID, $oRet, $ahWindows, $i $oRet = ObjCreate("System.Collections.ArrayList") $ahWindows = _WinAPI_EnumWindows() For $i = 1 To $ahWindows[0][0] _WinAPI_GetWindowThreadProcessId($ahWindows[$i][0], $iPID) ;byref! If _WinAPI_GetProcessName($iPID) = $sWantedProcess Then If StringRegExp($ahWindows[$i][1], $sClassFilter) Then $oRet.add($ahWindows[$i][0]) EndIf Next Return $oRet.toArray() EndFunc ;==>getProcessWindows Func captureWindow($hWnd, $iWidth = -1, $iHeight = -1) ;by chesstiger ;with minimized window workaround Local $hDDC, $hCDC, $hBmp Local $tWindowPlacement, $bMinimized, $iOldLong $tWindowPlacement = _WinAPI_GetWindowPlacement($hWnd) $bMinimized = ($tWindowPlacement.showCmd = @SW_SHOWMINIMIZED) If $bMinimized Then setMinAnimation(False) ;disable animations $iOldLong = _WinAPI_GetWindowLong($hWnd, $GWL_EXSTYLE) ;make window invisible _WinAPI_SetWindowLong($hWnd, $GWL_EXSTYLE, BitOR($iOldLong, $WS_EX_LAYERED)) _WinAPI_SetLayeredWindowAttributes($hWnd, 0, 0, $LWA_ALPHA) _WinAPI_ShowWindow($hWnd, @SW_RESTORE) ;restore window EndIf ;real screenshot If $iWidth = -1 Then $iWidth = _WinAPI_GetWindowWidth($hWnd) If $iHeight = -1 Then $iHeight = _WinAPI_GetWindowHeight($hWnd) $hDDC = _WinAPI_GetDC($hWnd) $hCDC = _WinAPI_CreateCompatibleDC($hDDC) $hBmp = _WinAPI_CreateCompatibleBitmap($hDDC, $iWidth, $iHeight) _WinAPI_SelectObject($hCDC, $hBmp) _WinAPI_PrintWindow($hWnd, $hCDC) _WinAPI_BitBlt($hCDC, 0, 0, 0, 0, $hDDC, 0, 0, 0x00330008) _WinAPI_ReleaseDC($hWnd, $hDDC) _WinAPI_DeleteDC($hCDC) If $bMinimized Then _WinAPI_ShowWindow($hWnd, @SW_MINIMIZE) ;minimize window _WinAPI_SetWindowLong($hWnd, $GWL_EXSTYLE, $iOldLong) ;make window visible again setMinAnimation(True) ;re-enable animations EndIf Return $hBmp EndFunc ;==>captureWindow Func setMinAnimation($bState) ;by chesstiger Local Const $SPI_SETANIMATION = 0x0049 Local Const $tagANIMATIONINFO = "uint cbSize;int iMinAnimate" Local $tAnimInfo $tAnimInfo = DllStructCreate($tagANIMATIONINFO) $tAnimInfo.iMinAnimate = $bState $tAnimInfo.cbSize = DllStructGetSize($tAnimInfo) _WinAPI_SystemParametersInfo($SPI_SETANIMATION, $tAnimInfo.cbSize, DllStructGetPtr($tAnimInfo)) EndFunc ;==>setMinAnimationAuf der Basis kannst du vermutlich recht leicht etwas basteln.

-
Nein, \" muss man nicht beachten. In AutoIt maskiert man das mit einer Doppelung. Und da man von vorne nach hinten durchgeht, kann man alles nach einem " bis zu einem einzelnen " ignorieren. Wenn dazwischen zwei doppelte Anführungszeichen hintereinander oder beliebig viele einzelne Anführungszeichen stehen, werden die korrekterweise übergangen.
-
Man muss das ja nicht mittels RegExp lösen.
Ganz trivial: Gehe die Datei zeichenweise (!) durch. Wende dabei folgende Regeln an:
- Falls man auf die Sequenz #cs stößt, alles bis zur Sequenz #ce entfernen (ggf. auch die ausgeschriebene Variante beachten).
- Falls man auf das Zeichen ; stößt, alles bis zur Sequenz CRLF entfernen.
- Falls man auf das Zeichen " stößt, alles bis zum nächsten einzelnen " ignorieren.
- Falls man auf das Zeichen ' stößt, alles bis zum nächsten einzelnen ' ignorieren.
Mir fällt so nichts ein, was das kaputt machen würde...
-
Ein paar Ansätze bzw. dafür nützliche Win32-Funktionen:
EnumChildWindows
GetWindowThreadProcessId
EnumWindows
-
Randbemerkung: Im EN-Forum gibt es eine tolle, eventbasierte TCP-UDF (von Kip, meine ich), mit der man ziemlich gut Server und Client schreiben kann. Sehr zu empfehlen.
-
Plattformunabhängigkeit schadet auf jeden Fall nicht.
Dabei ist noch zu beachten, dass sich nicht für alle genannten Bibliotheken mit einfachen Mitteln AutoIt-Bindings erstellen lassen. Als Beispiel sei hier Qt genannt: Qt wurde in C++ geschrieben und baut sehr stark auf dessen Objektorientierung auf. Das ist in AutoIt nicht wirklich angenehm zu händeln und lässt sich auch schlecht abbilden. Im Idealfall nimmt man daher eine C-Bibliothek wie Gtk+, denke ich. Trotz GObject geht das definitiv besser.
Wobei es eigentlich kein Problem darstellt, ein paar DLLs mitzuliefern. Erstens nehmen die nicht wirklich viel Speicherplatz ein und zweites stehen die meisten Toolkits unter Lizenzen wie der LGPL, was eine Weitergabe recht leicht macht.
-
Zunächst... Es gibt zig verschiedene GUI-Toolkits, mit denen du ein Fenster erzeugen und zeichnen kannst. Dabei ist das alles historisch gewachsen und dadurch auch etwas verworren. Die neueren arbeiten mit dynamischen Layouts, die älteren (wie bei AutoIt zu sehen) mit pixelgenauen Layouts. In der Unix/Linux-Welt sind da bekannte Vertreter Qt, wxWidgets oder GTK+. Auch Microsoft hat im Laufe der Zeit einige Toolkits entwickelt. DotNet verwendet bspw. WinForms. Dann gibt es noch WPF (Windows Presentation Foundation) für VC++. Und zu guter letzt existiert noch das wohl älteste Framework in diesem Bereich, nämlich Win32, auch einfach bekannt als WinAPI.
Die WinAPI ist aber fest an Pixellayouts gebunden. Es besteht theoretisch die Möglichkeit, ein anderes Framework aus AutoIt aufzurufen. Allerdings ist mir keine UDF in dem Bereich bekannt.
-
Na klar, das kann ja auch nicht funktionieren. Das Pattern besagt ausgeschrieben (und etwas vereinfacht).... Suche nach "<noscript" gefolgt von null oder mehr beliebigen Zeichen bis auf "%" gefolgt von "</noscript>". Es hakt an dem ausgeschlossenen Prozentzeichen, was ja ganz klar durch das URL-Encoding vorkommt (bspw. "/info/DE/1.Das1%2C1"). Wenn du [^%] (alles bis auf "%") durch . (beliebiges Zeichen) ersetzt, klappt das hier.
-
Man könnte sich was mit GDI+ bauen. Die Funktion _GDIPlus_GraphicsMeasureString erlaubt es, einen Text ziemlich gut in der Größe anzupassen. Am einfachsten zu kalkulieren wäre das aber mit einer Monospace-Schriftart.
-
Andy Die MT-Variante mit bits steht ja irgendwo. Ist aber leider auch langsamer.
Davon ab... Ich habe jetzt auch etwas rumprobiert. Eigentlich sollte RadixSort hier das mit Abstand schnellste sein. Im Durchschnittsfall (ist hier gegeben) hat QuickSort die Komplexitätsklasse O(n*log(n)), wie alle besseren vergleichenden Sortieralgorithmen. RadixSort liegt aber in O(n), ist also linear. Der Zeitbedarf steigt also linear mit jedem neuen zu sortierenden Objekt.
Wobei RadixSort nur effizient ist, wenn die maximale Schlüssellänge eher klein ist. Wenn man das klassischs RadixSort nimmt, wird nach Dezimalstellen sortiert, bei einem Int sind das dann maximal 10 Stellen. Das Problem ist wie gemacht für diesen Sortieralgorithmus. Spätestens bei großen Datenmengen sollte er gewinnen. Tut er aber nicht... Ich hab nur noch nicht raus, warum.
-
Ich glaube, das kann man z.B. mit RadixSort noch schneller lösen. RadixSort hat (bei bekannter Schlüssellänge, bei uns 32 bit) eine lineare Laufzeit, also O(l*n), nicht O(n*log(n)) wie QuickSort. Ich bastel nachher mal was in C...
-
Für ein ARGB-Bild benötigt man aber nicht zwangsweise 4 GB Speicher! Man kann den Speicherbedarf erheblich reduzieren, man muss nur bisher ungenutzten Speicher effektiv nutzen.
Im Endeffekt haben wir für jede mögliche Farbe (das sind 2^32 + 1, von #00000000 bis #FFFFFFFF) nur die Information, ob sie auftritt oder nicht. Zwei mögliche Zustände... Das schreit doch nach der Kodierung in einem Bit!
Man kann zum Beispiel ein 2^28 + 1 Array of Short (2 Byte) verwenden. (2^28 + 1) * 2 Byte = 536.870.914 Byte = 512 MByte. Das ist zwar auch nicht wenig, aber annehmbarer als 4 GByte.
Praktisch habe ich das so gelöst, dass die vordersten 4 Bit der Farbe (also die vordere Hälfte des Alpha-Wertes) mit dem jeweiligen Array-Element (indexiert durch die restlichen 28 Bit) verodert werden. Am Ende beim Summieren zähle ich dann einfach die Bits jedes Elementes. Funktioniert prima, und dauert bei Oscars Testbild inklusive LockBits... Ziemlich genau eine Sekunde, wobei davon auch nur knapp 400 ms für den DllCall draufgehen. Alles im Anhang!
C
Alles anzeigen#include "main.h" #include "32bit.h" unsigned short* colors32; unsigned int colorLen32 = 0x0fffffff + 1; //28 bit __inline int numberOfSetBits(unsigned int i) { /* here be dragons */ i = i - ((i >> 1) & 0x55555555); i = (i & 0x33333333) + ((i >> 2) & 0x33333333); return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24; } DWORD WINAPI colorThread32(void* data) { unsigned int i; pixelainfo_t* part = (pixelainfo_t*) data; for(i = 0; i < part->length; i++) { colors32[*(part->start + i) & 0x0fffffff] |= 1 << ((*(part->start + i) & 0xf0000000) >> 28); } return 0; } DWORD WINAPI additionThread32(void* data) { unsigned int i; countinfo_t* part = (countinfo_t*) data; part->ret = 0; for(i = 0; i < part->length; i++) { part->ret += numberOfSetBits(colors32[part->start + i]); } return 0; } long DLL_EXPORT getColorCount32(unsigned int* pixel, int len) { int i; long colorSum = 0; colors32 = (unsigned short*) calloc(colorLen32, sizeof(unsigned short)); HANDLE threads[THREADS]; pixelainfo_t* pixelparts[THREADS]; countinfo_t* countparts[THREADS]; for(i = 0; i < THREADS; i++) { /* partitioning pixel map and sum map, also start color count threads */ pixelparts[i] = (pixelainfo_t*) malloc(sizeof(pixelainfo_t)); pixelparts[i]->start = pixel + i * (len / THREADS); pixelparts[i]->length = len / THREADS; threads[i] = CreateThread(NULL, 0, colorThread32, pixelparts[i], 0, NULL); countparts[i] = (countinfo_t*) malloc(sizeof(countinfo_t)); countparts[i]->start = i * (colorLen32 / THREADS); countparts[i]->length = colorLen32 / THREADS; } /* wait for color count threads (JOIN) */ WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE); for(i = 0; i < THREADS; i++) { /* close color count threads, start addition threads */ CloseHandle(threads[i]); free(pixelparts[i]); threads[i] = CreateThread(NULL, 0, additionThread32, countparts[i], 0, NULL); } /* wait for addition threads (JOIN) */ WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE); for(i = 0; i < THREADS; i++) { /* close addition threads, calculate final sum from parts */ CloseHandle(threads[i]); colorSum += countparts[i]->ret; free(countparts[i]); } free(colors32); return colorSum; } -
Ah, das hab ich ganz übersehen. Bei mir kommt da raus...
klein: 18.49 ms
mittel: 33.51 ms
groß: 195.28 ms
riesig: 285.78 ms
Ist also dennoch ein My schneller als der simple C-Code von oben!
Selbst, wenn ich noch die Summation der Werte parallelisiere, ist da nicht mehr so viel zu holen.
( AspirinJunkie Da war echt noch was zu machen. Atomare Inkrements scheinen nicht ganz so performant zu sein... Aber auch hier macht sich MT nochmal bezahlt.)
klein: 19.78 ms
mittel: 32.83 ms
groß: 182.60 ms
riesig: 254.05 ms
Code
Alles anzeigen#define THREADS 4 typedef struct pixelainfo { /* pixel array info */ unsigned int* start; unsigned int length; } pixelainfo_t; typedef struct countinfo { unsigned int start; unsigned int length; unsigned int ret; } countinfo_t; unsigned char* colors; const int colorLen = 0xffffff + 1; DWORD WINAPI colorThread(void* data) { unsigned int i; pixelainfo_t* part = (pixelainfo_t*) data; for(i = 0; i < part->length; i++) { colors[*(part->start + i) & 0xffffff] = 1; } return 0; } DWORD WINAPI additionThread(void* data) { int i; countinfo_t* part = (countinfo_t*) data; part->ret = 0; for(i = 0; i < part->length; i++) { part->ret += colors[part->start + i]; } return 0; } int DLL_EXPORT getColorCount(unsigned int* pixel, int len) { int i, colorSum = 0; colors = (unsigned char*) calloc(colorLen, sizeof(unsigned char)); HANDLE threads[THREADS]; pixelainfo_t* pixelparts[THREADS]; countinfo_t* countparts[THREADS]; for(i = 0; i < THREADS; i++) { /* partitioning pixel map and sum map, also start color count threads */ pixelparts[i] = (pixelainfo_t*) malloc(sizeof(pixelainfo_t)); pixelparts[i]->start = pixel + i * (len / THREADS); pixelparts[i]->length = len / THREADS; threads[i] = CreateThread(NULL, 0, colorThread, pixelparts[i], 0, NULL); countparts[i] = (countinfo_t*) malloc(sizeof(countinfo_t)); countparts[i]->start = i * (colorLen / THREADS); countparts[i]->length = colorLen / THREADS; } /* wait for color count threads (JOIN) */ WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE); for(i = 0; i < THREADS; i++) { /* close color count threads, start addition threads */ CloseHandle(threads[i]); free(pixelparts[i]); threads[i] = CreateThread(NULL, 0, additionThread, countparts[i], 0, NULL); } /* wait for addition threads (JOIN) */ WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE); for(i = 0; i < THREADS; i++) { /* close addition threads, calculate final sum from parts */ CloseHandle(threads[i]); colorSum += countparts[i]->ret; free(countparts[i]); } free(colors); return colorSum; }Das ist noch etwas, aber nicht so viel, wie ich erwartet hätte. Wobei man fairerweise auch sagen muss, dass jetzt die Grenze des Machbaren erreicht ist. Der eigentliche DllCall dauert bei meiner neuen Multithreaded-Variante selbst für dein Riesen-Löwenzahnbild nur noch knappe 28 ms, also Pi mal Daumen 10% der Zeit. Der Rest geht für LockBits drauf..... Jetzt wäre der Moment gekommen, dort was zu optimieren.
Edit:
Ich habe mich jetzt mal etwas informiert. LockBits erstellt eine komplette Kopie der Bitmap. Das muss natürlich Ar...langsam sein. Man könnte evtl. GDIPlus durch was anderes ersetzen.
Edit²:
So, ich habe jetzt eine Implementation mit FreeImage gebastelt. Das Bild wird per FreeImage in AutoIt geladen und an meine DLL weitergegeben. Allerdings zeigt sich hier, dass die Werte für JPEGs etwas abweichen. Das Verhalten wurde ja schon zuvor beobachtet. Allerdings ist so nochmal ein MASSIVER Geschwindigkeitsvorteil zu erreichen. Beispiel am Löwenzahn-Bild: GDIPlus + DLL => ~250 ms, FreeImage + DLL => ~191.93 ms.
-
Also!
Das hier hat mir irgendwie keine Ruhe gelassen. Wir hatten jetzt Assembler, C, C++... Und C++ sogar multithreaded, allerdings durch die Sets relativ langsam. Ich hab also mal eine Implementation in purem Win32-C mit Threading geschrieben. So langsam muss ich aber auch kapitulieren. Hier mal die Statistiken, jeweils meine C-MT-Implementation gegen AspirinJunkies C++-Sets.
Folgende Bildmaße wurden verwendet: klein (1024x768), mittel (1920x1280), groß (5590x3731).
Codex | AJ Single | AJ Multi | CT Multi klein | 120.36 | 51.87 | 25.46 mittel | 375.95 | 151.47 | 36.89 groß | 2340.58 | 350.63 | 202.09Ich weiß zwar nicht, warum meine Implementation bei dem mittleren Bild so extrem heraussticht... Aber prinzipiell kann man so auf jeden Fall noch was rausholen! Ich teile das Bild einfach in mehrere gleiche Abschnitte auf und gehe diese dann in verschiedenen Threads durch. Am Ende, wenn alle Threads fertig sind, zähle ich die einzelnen Farben.
Code
Alles anzeigentypedef struct arrayinfo { unsigned int* start; unsigned int length; } arrayinfo_t; unsigned char* colors; const int colorLen = 0xffffff + 1; DWORD WINAPI colorThread(void* data) { unsigned int i; arrayinfo_t* part = (arrayinfo_t*) data; for(i = 0; i < part->length; i++) { colors[*(part->start + i) & 0xffffff] = 1; } return 0; } int DLL_EXPORT getColorCount(unsigned int* pixel, int len) { int i, colorSum = 0; colors = (unsigned char*) calloc(colorLen, sizeof(unsigned char)); HANDLE threads[THREADS]; arrayinfo_t* data[THREADS]; for(i = 0; i < THREADS; i++) { data[i] = (arrayinfo_t*) malloc(sizeof(arrayinfo_t)); data[i]->start = pixel + i * (len / THREADS); data[i]->length = len / THREADS; threads[i] = CreateThread(NULL, 0, colorThread, data[i], 0, NULL); } WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE); for(i = 0; i < THREADS; i++) { CloseHandle(threads[i]); free(data[i]); } //calculate sum for(i = 0; i < colorLen; i++) colorSum += colors[i]; free(colors); return colorSum; }DLL, vollständiger Source usw. alles im Anhang.