Beiträge von UEZ

**UEZ**

Ich habe nach langer Pause weitergemacht und mit Unterstützung der KIs in Free Basic es hinbekommen, dass die Textur Rotation gemäß dem Richtungsvektor realistisch aussieht.

Siehe Post#2 für die Link zu meinem 1Drv.

https://i.ibb.co/GQf6S9xk/Captured.webp

[Blockierte Grafik: https://i.ibb.co/GQf6S9xk/Captured.webp]

**UEZ**

Sieht fehlerfrei aus.

Mittlerweile ist auch PNG in die Tage gekommen und es gibt bessere Alternativen wie WebP und Avif, die besser verlustfrei komprimieren.

Vielleicht schreibe ich auch eine Avif DLL...

Btw, Gimp unterstützt QOI (R/W).

**UEZ** · WebP v0.5.0 build 2025-08-23 beta **UEZ** 4. August 2025 um 00:37

Es wurden umfangreiche Aktualisierungen an der DLL und der UDF vorgenommen und Fehler behoben (möglicherweise wurden neue hinzugefügt). Alle Beispiele wurden auf die neue DLL/UDF umgestellt.

Alte Skripte können fehlschlagen, wenn Sie DLL v0.4.3+ verwenden, da sich die Funktionsparameter geändert haben.

Es wurde eine Funktion zum Konvertieren von APNG in AWEBP hinzugefügt.

**UEZ** · WebP v0.5.0 build 2025-08-23 beta **UEZ** 2. Juli 2025 um 15:36

Auf Version WebP v0.3.6 build 2025-07-02 beta aktualisiert.

Ich habe jetzt eine Funktion hinzugefügt, um GIF animierte Dateien nach WebP umzuwandeln.

Siehe Example10.au3 auf meinem 1Drv.

**UEZ** · WebP v0.5.0 build 2025-08-23 beta **UEZ** 27. Juni 2025 um 14:22

Auf Version WebP v0.3.5 build 2025-06-30 beta aktualisiert.

Nun können WebP Animationen erstellt werden. Beispiel 8 und 9.

**UEZ**

AutoIt

Func _IntegerToRoman($sInteger)
	Local $Return = "", $i, $j[] = [1, 4, 5, 9], $num = $sInteger, $value, $sRoman = "IIVIXXLXCCDCM" ;alle möglichen Zeichenpaare der römischen Zahlensymbole kompakt aneinandergereiht
	For $i = 12 To 0 Step -1
		$value = $j[Mod($i, 4)] * 10 ^ BitShift($i, 2) ;berechnet den konkreten Wert für die aktuelle Position, z.B. 1000, 900, 500, 400, ..., 1
		While $num >= $value
			$Return &= StringMid($sRoman, $i + 1, Mod($i, 2) + 1) ;die passenden römischen Zeichen (1 oder 2 Buchstaben) werden aus $sRoman extrahiert und angehängt
			$num -= $value
		WEnd
	Next
	Return $Return
EndFunc   ;==>_IntegerToRoman

Func _RomanToInteger($sRoman)
	Local $i, $Return = 0, $map[13][2] = [["M", 1000], ["CM", 900], ["D", 500], ["CD", 400], ["C", 100], ["XC", 90], ["L", 50], ["XL", 40], ["X", 10], ["IX", 9], ["V", 5], ["IV", 4], ["I", 1]]
	$sRoman = StringUpper($sRoman)
	While StringLen($sRoman) > 0
		For $i = 0 To UBound($map) - 1
			If StringLeft($sRoman, StringLen($map[$i][0])) = $map[$i][0] Then
				$Return += $map[$i][1]
				$sRoman = StringTrimLeft($sRoman, StringLen($map[$i][0]))
				ExitLoop
			EndIf
		Next
	WEnd
	Return $Return
EndFunc   ;==>_RomanToInteger

; Bonus-Aufgabe für Ambitionierte ;-)
Func _DateToRoman($sDate) ;Input date in the format "YYYY/MM/DD [HH:MM:SS]", Output in same date-format with roman sign
	Local $aTokens = StringRegExp($sDate, "(\d{2})/(\d{2})/(\d{4})(?: (\d{2})(?::(\d{2}))?(?::(\d{2}))?)?", 1), $ub = UBound($aTokens)
	Return StringFormat("%02s/%02s/%04s %02s:%02s:%02s", _IntegerToRoman($aTokens[0]), _IntegerToRoman($aTokens[1]), _IntegerToRoman($aTokens[2]), $ub > 3 ? _IntegerToRoman($aTokens[3]) : "",  $ub > 4 ? _IntegerToRoman($aTokens[4]) : "",  $ub > 5 ? _IntegerToRoman($aTokens[5]) : "")
EndFunc   ;==>_DateToRoman

Alles anzeigen

**UEZ**

Nicht immer liegt in der Kürze die Würze.

Glückwunsch an AspirinJunkie Sehr clever Look-up Table und Maps zu benutzen! auch an Mars - liegt knapp dahinter. Man könnte fast von einem Unentschieden sprechen...

**UEZ**

Dann poste ich auch meine Version:

AutoIt

Global $aSonder[44], $mapSonder[127], $aChar[128], $slen = 43, $i = 1, $j
For $j = 31 To 127
	If Not(($j > 64 And $j < 91) Or ($j > 96 And $j < 123)) And $j > 31 And $j < 127 Then
		$aSonder[$i] = Chr($j)
		$mapSonder[Asc($aSonder[$i])] = $i
		$i += 1
	EndIf
	$aChar[$j] = Chr($j)
Next

ConsoleWrite(_Check() & @CRLF)

Func _CypherEnigma($sString, $nKlein, $nGross, $nSonder, $nExtra)
	Local $Return, $i, $j = 1, $a, $pos, $newPos, $aString = StringSplit($sString, ""), $iLen = $aString[0]
	For $i = 1 To $iLen
		$a = Asc($aString[$i])
		Switch $a
			Case 65 To 90 ;Großbuchstaben
				$Return &= $aChar[65 + (Mod($a - 65 + $nGross + ($i * $nExtra), 26))]
			Case 97 To 122 ;Kleinbuchstaben
				$Return &= $aChar[97 + (Mod($a - 97 + $nKlein + ($i * $nExtra), 26))]
			Case 32 To 64, 91 To 96, 123 To 126 ;Sonderzeichen ohne Buchstaben
				$pos = $mapSonder[$a]
				$newPos = Mod(($pos - 1 + $nSonder + ($i * $nExtra)), $slen)
				$Return &= $aSonder[$newPos + 1]
			Case Else ;Steuerzeichen oder > 126
				$Return &= $aString[$i]
		EndSwitch
	Next
	Return $Return
EndFunc   ;==>_CypherEnigma

Alles anzeigen

**UEZ**

Mit Cairo kannst du auch PDFs erstellen -> https://www.autoitscript.com/forum/topic/21…024-04-02-alpha

Siehe dazu Beispiel "Example15.au3".

**UEZ**

Das Problem beim Dark Mode ist nur, dass der Kontrast fehlt und man die Ränder der Fenster nicht auf anhieb sieht, wenn sie z.B. übereinander liegen und man "verklickt" sich. Ansonsten "strahlt" das Fenster nicht, was angenehmer für die Augen ist.

**UEZ**

Scheint eventuell ein Bug zu sein, denn die globale Variable $mUnit ist nicht vollständig in der Funktion _WM_DRAWITEM sichtbar, selbst wann man aus der _WM_DRAWITEM Funktion eine andere Function aufruft.

Kanashius die Farbe wird dann für alle gesetzt und nicht nach "Access".

**UEZ**

Ich denke, dass Musashi recht hat für MP3 Dateien, denn laut ChatGPT

Zitat
wenn du mehrere MP3-Dateien programmatisch zu einer einzigen Datei zusammenfügen möchtest, gibt es einige Dinge zu beachten:
1. Gleiche Audioeigenschaften
Alle MP3-Dateien sollten dieselbe Bitrate, Sample-Rate und Kanäle (Mono/Stereo) haben, um Qualitätsverluste oder unerwartete Verzerrungen zu vermeiden.
Falls die Dateien unterschiedliche Formate haben, musst du sie zuerst umwandeln (z. B. mit ffmpeg).
2. Metadaten & ID3-Tags
Beim Zusammenfügen können ID3-Tags verloren gehen oder vermischt werden. Es ist ratsam, die Metadaten nach dem Zusammenfügen neu zu setzen.
3. Frames korrekt verbinden
MP3-Dateien bestehen aus Frames. Ein einfaches Aneinanderhängen von Dateien kann zu hörbaren Störungen führen, falls nicht sauber geschnitten wird.
Programme wie ffmpeg oder sox können die Dateien korrekt ohne Fehler zusammenführen.
4. Korrekte Methoden zum Zusammenfügen
Mit ffmpeg (empfohlen):
Code
ffmpeg -i "concat:file1.mp3|file2.mp3|file3.mp3" -acodec copy output.mp3
Falls das nicht funktioniert, kann man die Dateien erst in eine Textdatei schreiben:
Code
shCopyEditecho "file 'file1.mp3'" > mylist.txt
echo "file 'file2.mp3'" >> mylist.txt
ffmpeg -f concat -safe 0 -i mylist.txt -c copy output.mp3

was plausibel klingt.

**UEZ**

Scheint so zu funzen:

AutoIt

;Coded by UEZ build 2025-27-02 beta
#include <WinAPIFiles.au3>
#include <WinAPIHObj.au3>
#include <Array.au3>
#include <File.au3>
Global $aMP3Files = _FileListToArray("c:\Audio Files\MP3\", "*.mp3", $FLTA_FILES, True) ;Pfad anpassen!
MergeFiles($aMP3Files, "c:\Temp\Test.mp3") ;Pfad anpassen!
Func MergeFiles($aFiles, $sOutputFilename)
    Local $aFileSizes[$aFiles[0]][2], $i, $iTotalSize = 0
    For $i = 0 To UBound($aFileSizes) - 1
        $aFileSizes[$i][0] = FileGetSize($aFiles[$i + 1])
        $iTotalSize += $aFileSizes[$i][0]
    Next
	Local $hFile = _WinAPI_CreateFile($sOutputFilename, 1, 4), $hFileChunk, $iRead, $iBytes, $pos
	Local $tMem = DllStructCreate("ubyte data[" & $iTotalSize & "]")
	$aFileSizes[0][1] = DllStructCreate("ubyte part[" & $aFileSizes[0][0] & "]", DllStructGetPtr($tMem))
	$hFileChunk = _WinAPI_CreateFile($aFiles[1], 2, 2)
	_WinAPI_ReadFile($hFileChunk, $aFileSizes[0][1], $aFileSizes[0][0], $iRead)
	_WinAPI_CloseHandle($hFileChunk)
	$pos = $aFileSizes[0][0]
	For $i = 1 To UBound($aFileSizes) - 1
		$aFileSizes[$i][1] = DllStructCreate("ubyte part[" & $aFileSizes[$i][0] & "]", DllStructGetPtr($tMem) + $pos + 1)
		$pos += $aFileSizes[$i][0]
		$hFileChunk = _WinAPI_CreateFile($aFiles[$i + 1], 2, 2)
		_WinAPI_ReadFile($hFileChunk, $aFileSizes[$i][1], $aFileSizes[$i][0], $iRead)
		_WinAPI_CloseHandle($hFileChunk)
	Next
	_WinAPI_WriteFile($hFile, $tMem, $iTotalSize, $iBytes)
	_WinAPI_CloseHandle($hFile)
EndFunc

Alles anzeigen

Natürlich sollte das Array mit den Files entsprechend sortiert sein, aber das überlasse ich Moombas.

**UEZ**

Wenn die Dateien, die zusammengesetzt werden sollen, nicht riesig sind, dann kannst du doch die Dateien in eine Struct laden und dann die Struct in einer Datei speichern.

Du müsstest dann n Pointer auf die gesamte Struct erstellen und sie dann mit _WinAPI_ReadFile() für die n Dateien nutzen.

Zumindest so die Theorie...

**UEZ**

Zitat von SOLVE-SMART

Egal wie ausgeklügelt man da heran geht, umso mehr Malware mit AutoIt-Code geschrieben und genutzt wird (sei es nur Spiele-Cracks), umso häufiger werden die Virenscan-Hersteller diese Signaturen auch in ihre Datenbanken mit aufnehmen.

Genau auch meine Meinung, falls diese Möglichkeit besser funktioniert, dauert es bestimmt nicht lange, bis sie Kriminelle für ihre eigene Zwecke missbrauchen und die Mühe war umsonst.

Ich weiß nicht seit wann, aber Windows Defender klassifiziert auch *.au3 Files als Trojaner!

Code

Microsoft Defender Antivirus has detected malware or other potentially unwanted software.
 For more information please see the following:
https://go.microsoft.com/fwlink/?linkid=37020&name=Trojan:AutoIt/Prcablt.SD!MTB&threatid=2147740918&enterprise=1
 	Name: Trojan:AutoIt/Prcablt.SD!MTB
 	ID: 2147740918
 	Severity: Severe
 	Category: Trojan
 	Path: containerfile:_C:\Coding\AU3\Internet\Mp3SearchEngine\Mp3SearchEngine v1.0.8.8.au3; containerfile:_C:\Coding\AU3\Tools\WallpaperBank\WallpaperBank v1.0.2.0.au3; file:_C:\Coding\AU3\Internet\Mp3SearchEngine2\Mp3SearchEngine_v2.0.1.1.au3; file:_C:\Coding\AU3\Internet\Mp3SearchEngine\Mp3SearchEngine v1.0.8.8.au3->(UTF-8); file:_C:\Coding\AU3\SystemInfo\CompStats\Computer Stats Utility 2.0.2.0.au3; file:_C:\Coding\AU3\Tools\HTML Imager\HTML Imager v1.0.1.1.au3; file:_C:\Coding\AU3\Tools\HTML Imager\HTML Imager v1.0.1.2.au3; file:_C:\Coding\AU3\Tools\HTML Imager\HTML Imager v1.0.1.3.au3; file:_C:\Coding\AU3\Tools\ImageSplitter\ImageSplitter v1.0.0.7.au3; file:_C:\Coding\AU3\Tools\Mp3SearchEngine\Mp3SearchEngine v1.0.9.2.au3; file:_C:\Coding\AU3\Tools\WallpaperBank\WallpaperBank v1.0.2.0.au3->(UTF-8); file:_C:\Coding\AU3\Video\XvidCapture\BackUp\XvidCapture v1.0.1.6_old1.au3; file:_C:\Coding\AU3\Video\XvidCaptur
 	Detection Origin: Local machine
 	Detection Type: Concrete
 	Detection Source: System
 	User: NT AUTHORITY\SYSTEM
 	Process Name: C:\Programme\Editor\Notepad3\Notepad3.exe
 	Security intelligence Version: AV: 1.421.1531.0, AS: 1.421.1531.0, NIS: 1.421.1531.0
 	Engine Version: AM: 1.1.24090.11, NIS: 1.1.24090.11

Alles anzeigen

Bin gespannt, wann *.a3x als Malware erkannt werden...

**UEZ**

Versuche es mal damit:

AutoIt

;Kontextmenü - benutzerdefiniert
Global $w_editBoxProcNew = DllCallbackRegister("_MyWindowProc", "ptr", "hwnd;uint;wparam;lparam")
Global $w_editBoxProcOld = _WinAPI_SetWindowLong(GUICtrlGetHandle($idEdit_notiz), $GWL_WNDPROC, DllCallbackGetPtr($w_editBoxProcNew))
;_WinAPI_SetWindowLong(GUICtrlGetHandle($idEdit_notiz), $GWL_WNDPROC, DllCallbackGetPtr($w_editBoxProcNew))

Frohes Neues!

**UEZ**

Zitat von AspirinJunkie

Ein in AutoIt eingebauter C-Compiler wäre schon fein wenn das als "Abfallprodukt" hinten raus fällt.

Das gibt es auch - ein Inline C Compiler von Ward -> https://www.autoitscript.com/forum/topic/16…-call-in-autoit

**UEZ**

Man kann auch die DLLs in das Skript integrieren (Base64) und per MemCall() aufrufen, somit würde das Weitergeben der DLL entfallen. Rust scheint ja echt kleine DLLs im Gegensatz zu Freebasic zu generieren, sodass das Integrieren nicht unnötig den Code aufbläht. Freebasic ist anscheinden wie mein Bauch...

Das Aktualisieren wäre sicherlich auch einfacher, als mit dem ASM Code.

Andy kleine Doktorarbeit zum Thema Assembler gepostet

Ich persönlich vergesse sehr schnell das Programmieren in ASM und mir fällt es schwer wieder rein zu kommen. Bei dir ist das anscheinend in Fleisch und Blut übergegangen.

**UEZ**

Zitat von Andy

Cool, bin nur drübergeflogen, aber wie das aussieht, ist der "clevere" Teil von dir geschrieben. Zeig mal bitte den Freebasic-code.

Den ASM Code hat der Compiler gebastelt - der FB Code ist simpel:

Code

#ifdef __FB_64BIT__
	#cmdline "-RR -m Sum64 -dll -export -gen gcc -Wc -Ofast -Wc -march=native -Wc -funroll-loops -Wc -mfpmath=sse"
#else
    #cmdline "-RR -m Sum -dll -export -gen gcc -Wc -Ofast -Wc -march=native -Wc -funroll-loops -Wc -mfpmath=sse"
#endif

Extern "Windows-MS"
	
Function SumF(tStruct As Double Ptr, iLen As ULong) As Single Export
	Dim As Single fSum = 0
	For i As ULong = 0 To iLen - 1
		fSum += tStruct[i]
	Next
	Return fSum
End Function
	
Function SumD(tStruct As Double Ptr, iLen As ULong) As Double Export
	Dim As Double fSum = 0
	For i As ULong = 0 To iLen - 1
		fSum += tStruct[i]
	Next
	Return fSum
End Function
End Extern

Alles anzeigen

Man kann auch die Optimierung ausschalten, damit mehr Kompatibilität ensteht, aber zugunsten der Geschwindigkeit.

Zitat von AspirinJunkie

Hui und wie mache ich daraus einen in AutoIt verwendbaren Binärcode?
Gar nicht. Wenn ich ein Float-array habe dann soll der Float-Code verwendet werden. Gemischt wird natürlich nicht.
Ansonsten möchte ich ja eben keine Dlls dazulegen, sondern das bewusst intern im AutoIt-Code selbst mitliefern.
Aber danke schonmal Jungs. Wusste doch, dass ich die Spezis damit anfixe.

Ich muss mal checken, wie man aus dem Code ein Binär Code erstellt, sodass man ihn einfach per DLLCallAddress aufruft.

Wie du in der Funktion SumF sehen kannst, ist innerhalb der Funktion die Variable fSum als Single (Float) definiert, d.h. die Summe ist anders als mit Double, deshalb meine Nachfrage.

**UEZ**

Das ist der optimierte x64 ASM Output vom Compiler:

Code

	.file	"Sum.c"
	.intel_syntax noprefix
	.text
/APP
	.section .drectve
	.ascii " -export:\"SumF\""
	.ascii " -export:\"SumD\""

	.text
/NO_APP
	.p2align 4
	.globl	SumF
	.def	SumF;	.scl	2;	.type	32;	.endef
	.seh_proc	SumF
SumF:
	.seh_endprologue
	vxorps	xmm0, xmm0, xmm0
	mov	eax, 1
	dec	edx
	vcvtsd2ss	xmm0, xmm0, QWORD PTR [rcx]
	mov	r8d, edx
	and	r8d, 7
	cmp	edx, 1
	jb	.L42
	test	r8d, r8d
	je	.L2
	cmp	r8d, 1
	je	.L28
	cmp	r8d, 2
	je	.L29
	cmp	r8d, 3
	je	.L30
	cmp	r8d, 4
	je	.L31
	cmp	r8d, 5
	je	.L32
	cmp	r8d, 6
	jne	.L44
.L33:
	mov	r9d, eax
	vcvtss2sd	xmm3, xmm0, xmm0
	inc	eax
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r9*8]
	vcvtsd2ss	xmm0, xmm4, xmm4
.L32:
	mov	r10d, eax
	vcvtss2sd	xmm5, xmm0, xmm0
	inc	eax
	vaddsd	xmm0, xmm5, QWORD PTR [rcx+r10*8]
	vcvtsd2ss	xmm0, xmm0, xmm0
.L31:
	mov	r11d, eax
	vcvtss2sd	xmm1, xmm0, xmm0
	inc	eax
	vaddsd	xmm2, xmm1, QWORD PTR [rcx+r11*8]
	vcvtsd2ss	xmm0, xmm2, xmm2
.L30:
	mov	r8d, eax
	vcvtss2sd	xmm3, xmm0, xmm0
	inc	eax
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r8*8]
	vcvtsd2ss	xmm0, xmm4, xmm4
.L29:
	mov	r9d, eax
	vcvtss2sd	xmm5, xmm0, xmm0
	inc	eax
	vaddsd	xmm0, xmm5, QWORD PTR [rcx+r9*8]
	vcvtsd2ss	xmm0, xmm0, xmm0
.L28:
	mov	r10d, eax
	vcvtss2sd	xmm1, xmm0, xmm0
	inc	eax
	vaddsd	xmm2, xmm1, QWORD PTR [rcx+r10*8]
	vcvtsd2ss	xmm0, xmm2, xmm2
	cmp	edx, eax
	jb	.L42
.L2:
	mov	r11d, eax
	vcvtss2sd	xmm3, xmm0, xmm0
	lea	r8d, 1[rax]
	lea	r9d, 2[rax]
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r11*8]
	lea	r10d, 3[rax]
	lea	r11d, 4[rax]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r8*8]
	lea	r8d, 5[rax]
	vcvtsd2ss	xmm2, xmm1, xmm1
	vcvtss2sd	xmm3, xmm2, xmm2
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r9*8]
	lea	r9d, 6[rax]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r10*8]
	lea	r10d, 7[rax]
	add	eax, 8
	vcvtsd2ss	xmm2, xmm1, xmm1
	vcvtss2sd	xmm3, xmm2, xmm2
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r11*8]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r8*8]
	vcvtsd2ss	xmm2, xmm1, xmm1
	vcvtss2sd	xmm3, xmm2, xmm2
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+r9*8]
	vcvtsd2ss	xmm5, xmm4, xmm4
	vcvtss2sd	xmm0, xmm5, xmm5
	vaddsd	xmm1, xmm0, QWORD PTR [rcx+r10*8]
	vcvtsd2ss	xmm0, xmm1, xmm1
	cmp	edx, eax
	jnb	.L2
.L3:
.L42:
	ret
	.p2align 4
	.p2align 3
.L44:
	vcvtss2sd	xmm1, xmm0, xmm0
	vaddsd	xmm2, xmm1, QWORD PTR 8[rcx]
	mov	eax, 2
	vcvtsd2ss	xmm0, xmm2, xmm2
	jmp	.L33
	.seh_endproc
	.p2align 4
	.globl	SumD
	.def	SumD;	.scl	2;	.type	32;	.endef
	.seh_proc	SumD
SumD:
	.seh_endprologue
	lea	r8d, -1[rdx]
	cmp	edx, 6
	jbe	.L50
	lea	r9d, -2[rdx]
	vmovups	xmm1, XMMWORD PTR [rcx]
	mov	r10d, 1
	shr	r9d
	lea	eax, 1[r9]
	and	r9d, 7
	cmp	eax, 1
	jbe	.L125
	test	r9d, r9d
	je	.L47
	cmp	r9d, 1
	je	.L105
	cmp	r9d, 2
	je	.L106
	cmp	r9d, 3
	je	.L107
	cmp	r9d, 4
	je	.L108
	cmp	r9d, 5
	je	.L109
	cmp	r9d, 6
	je	.L110
	vaddpd	xmm1, xmm1, XMMWORD PTR 16[rcx]
	mov	r10d, 2
.L110:
	mov	r11, r10
	inc	r10
	sal	r11, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r11]
.L109:
	mov	r8, r10
	inc	r10
	sal	r8, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r8]
.L108:
	mov	r9, r10
	inc	r10
	sal	r9, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r9]
.L107:
	mov	r11, r10
	inc	r10
	sal	r11, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r11]
.L106:
	mov	r8, r10
	inc	r10
	sal	r8, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r8]
.L105:
	mov	r9, r10
	inc	r10
	sal	r9, 4
	vaddpd	xmm1, xmm1, XMMWORD PTR [rcx+r9]
	cmp	eax, r10d
	jbe	.L125
.L47:
	mov	r11, r10
	mov	r8, r10
	mov	r9, r10
	sal	r11, 4
	sal	r8, 4
	sal	r9, 4
	vaddpd	xmm0, xmm1, XMMWORD PTR [rcx+r11]
	mov	r11, r10
	sal	r11, 4
	vaddpd	xmm2, xmm0, XMMWORD PTR 16[rcx+r8]
	mov	r8, r10
	sal	r8, 4
	vaddpd	xmm3, xmm2, XMMWORD PTR 32[rcx+r9]
	mov	r9, r10
	sal	r9, 4
	vaddpd	xmm4, xmm3, XMMWORD PTR 48[rcx+r11]
	mov	r11, r10
	sal	r11, 4
	vaddpd	xmm5, xmm4, XMMWORD PTR 64[rcx+r8]
	mov	r8, r10
	add	r10, 8
	sal	r8, 4
	vaddpd	xmm1, xmm5, XMMWORD PTR 80[rcx+r9]
	vaddpd	xmm0, xmm1, XMMWORD PTR 96[rcx+r11]
	vaddpd	xmm1, xmm0, XMMWORD PTR 112[rcx+r8]
	cmp	eax, r10d
	ja	.L47
.L125:
	vunpckhpd	xmm2, xmm1, xmm1
	add	eax, eax
	vaddpd	xmm0, xmm2, xmm1
	cmp	edx, eax
	je	.L126
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rax*8]
.L49:
.L126:
	ret
	.p2align 4
	.p2align 3
.L50:
	mov	edx, r8d
	vmovsd	xmm0, QWORD PTR [rcx]
	mov	r10d, 1
	and	edx, 7
	cmp	r8d, 1
	jb	.L126
	test	edx, edx
	je	.L46
	cmp	edx, 1
	je	.L99
	cmp	edx, 2
	je	.L100
	cmp	edx, 3
	je	.L101
	cmp	edx, 4
	je	.L102
	cmp	edx, 5
	je	.L103
	cmp	edx, 6
	je	.L104
	vaddsd	xmm0, xmm0, QWORD PTR 8[rcx]
	mov	r10d, 2
.L104:
	mov	eax, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rax*8]
.L103:
	mov	r9d, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+r9*8]
.L102:
	mov	r11d, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+r11*8]
.L101:
	mov	edx, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rdx*8]
.L100:
	mov	eax, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+rax*8]
.L99:
	mov	r9d, r10d
	inc	r10d
	vaddsd	xmm0, xmm0, QWORD PTR [rcx+r9*8]
	cmp	r8d, r10d
	jb	.L126
.L46:
	mov	r11d, r10d
	lea	edx, 1[r10]
	lea	eax, 2[r10]
	lea	r9d, 3[r10]
	vaddsd	xmm3, xmm0, QWORD PTR [rcx+r11*8]
	lea	r11d, 4[r10]
	vaddsd	xmm4, xmm3, QWORD PTR [rcx+rdx*8]
	lea	edx, 5[r10]
	vaddsd	xmm5, xmm4, QWORD PTR [rcx+rax*8]
	lea	eax, 6[r10]
	vaddsd	xmm1, xmm5, QWORD PTR [rcx+r9*8]
	lea	r9d, 7[r10]
	add	r10d, 8
	vaddsd	xmm0, xmm1, QWORD PTR [rcx+r11*8]
	vaddsd	xmm2, xmm0, QWORD PTR [rcx+rdx*8]
	vaddsd	xmm3, xmm2, QWORD PTR [rcx+rax*8]
	vaddsd	xmm0, xmm3, QWORD PTR [rcx+r9*8]
	cmp	r8d, r10d
	jnb	.L46
	jmp	.L126
	.seh_endproc

Alles anzeigen

x86:

Code

	.intel_syntax noprefix

.section .text
.balign 16

.globl _DllMain@12
_DllMain@12:
push ebp
mov ebp, esp
sub esp, 4
mov dword ptr [ebp-4], 0
.L_0004:
mov dword ptr [ebp-4], 1
cmp dword ptr [ebp+12], 1
jne .L_0006
push 0
push 0
call _main
add esp, 8
.L_0006:
.L_0005:
mov eax, dword ptr [ebp-4]
mov esp, ebp
pop ebp
ret 12
.balign 16

.globl _SumF
_SumF:
push ebp
mov ebp, esp
sub esp, 16
push ebx
mov dword ptr [ebp-4], 0
.L_0007:
push dword ptr [_Lt_000E]
pop dword ptr [ebp-8]
mov dword ptr [ebp-12], 0
mov eax, dword ptr [ebp+12]
add eax, 4294967295
mov dword ptr [ebp-16], eax
jmp .L_000A
.L_000D:
fld dword ptr [ebp-8]
mov eax, dword ptr [ebp-12]
sal eax, 3
mov ebx, dword ptr [ebp+8]
add ebx, eax
fadd qword ptr [ebx]
fstp dword ptr [ebp-8]
.L_000B:
inc dword ptr [ebp-12]
.L_000A:
mov ebx, dword ptr [ebp-16]
cmp dword ptr [ebp-12], ebx
jbe .L_000D
.L_000C:
push dword ptr [ebp-8]
pop dword ptr [ebp-4]
.L_0008:
fld dword ptr [ebp-4]
pop ebx
mov esp, ebp
pop ebp
ret 8
.balign 16

.globl _SumD
_SumD:
push ebp
mov ebp, esp
sub esp, 24
push ebx
mov dword ptr [ebp-8], 0
mov dword ptr [ebp-4], 0
.L_000F:
push dword ptr [_Lt_0016]
push dword ptr [_Lt_0016+4]
pop dword ptr [ebp-12]
pop dword ptr [ebp-16]
mov dword ptr [ebp-20], 0
mov eax, dword ptr [ebp+12]
add eax, 4294967295
mov dword ptr [ebp-24], eax
jmp .L_0012
.L_0015:
mov eax, dword ptr [ebp-20]
sal eax, 3
mov ebx, dword ptr [ebp+8]
add ebx, eax
fld qword ptr [ebx]
fadd qword ptr [ebp-16]
fstp qword ptr [ebp-16]
.L_0013:
inc dword ptr [ebp-20]
.L_0012:
mov ebx, dword ptr [ebp-24]
cmp dword ptr [ebp-20], ebx
jbe .L_0015
.L_0014:
push dword ptr [ebp-16]
push dword ptr [ebp-12]
pop dword ptr [ebp-4]
pop dword ptr [ebp-8]
.L_0010:
fld qword ptr [ebp-8]
pop ebx
mov esp, ebp
pop ebp
ret 8
.balign 16
_main:
push ebp
mov ebp, esp
and esp, 0xFFFFFFF0
sub esp, 12
mov dword ptr [ebp-4], 0
call ___main
push 0
push dword ptr [ebp+12]
push dword ptr [ebp+8]
call _fb_Init@12
.L_0002:
.L_0003:
mov eax, dword ptr [ebp-4]
mov esp, ebp
pop ebp
ret

.section .data
.balign 4
_Lt_000E:	.long	0x00000000
.balign 8
_Lt_0016:	.quad	0x0000000000000000

.section .drectve
	.ascii " -export:SumF"

	.ascii " -export:SumD"

Alles anzeigen

x64:

Code

	.file	"Sum.c"
	.intel_syntax noprefix
	.text
	.globl	SumF
	.def	SumF;	.scl	2;	.type	32;	.endef
	.seh_proc	SumF
SumF:
	push	rbp
	.seh_pushreg	rbp
	mov	rbp, rsp
	.seh_setframe	rbp, 0
	sub	rsp, 16
	.seh_stackalloc	16
	.seh_endprologue
	mov	QWORD PTR 16[rbp], rcx
	mov	DWORD PTR 24[rbp], edx
	lea	rax, -16[rbp]
	mov	DWORD PTR [rax], 0
.L2:
	pxor	xmm0, xmm0
	movss	DWORD PTR -4[rbp], xmm0
	mov	DWORD PTR -8[rbp], 0
	mov	eax, DWORD PTR 24[rbp]
	sub	eax, 1
	mov	DWORD PTR -12[rbp], eax
	jmp	.L3
.L10:
	nop
.L4:
	cvtss2sd	xmm1, DWORD PTR -4[rbp]
	mov	eax, DWORD PTR -8[rbp]
	sal	rax, 3
	mov	rdx, rax
	mov	rax, QWORD PTR 16[rbp]
	add	rax, rdx
	movsd	xmm0, QWORD PTR [rax]
	addsd	xmm0, xmm1
	cvtsd2ss	xmm0, xmm0
	movss	DWORD PTR -4[rbp], xmm0
.L5:
	mov	eax, DWORD PTR -8[rbp]
	add	eax, 1
	mov	DWORD PTR -8[rbp], eax
.L3:
	mov	eax, DWORD PTR -8[rbp]
	cmp	eax, DWORD PTR -12[rbp]
	jbe	.L10
	nop
.L6:
	movss	xmm0, DWORD PTR -4[rbp]
	movss	DWORD PTR -16[rbp], xmm0
	nop
.L7:
	movss	xmm0, DWORD PTR -16[rbp]
	add	rsp, 16
	pop	rbp
	ret
	.seh_endproc
	.globl	SumD
	.def	SumD;	.scl	2;	.type	32;	.endef
	.seh_proc	SumD
SumD:
	push	rbp
	.seh_pushreg	rbp
	mov	rbp, rsp
	.seh_setframe	rbp, 0
	sub	rsp, 32
	.seh_stackalloc	32
	.seh_endprologue
	mov	QWORD PTR 16[rbp], rcx
	mov	DWORD PTR 24[rbp], edx
	lea	rax, -24[rbp]
	mov	QWORD PTR [rax], 0
.L12:
	pxor	xmm0, xmm0
	movsd	QWORD PTR -8[rbp], xmm0
	mov	DWORD PTR -12[rbp], 0
	mov	eax, DWORD PTR 24[rbp]
	sub	eax, 1
	mov	DWORD PTR -16[rbp], eax
	jmp	.L13
.L20:
	nop
.L14:
	mov	eax, DWORD PTR -12[rbp]
	sal	rax, 3
	mov	rdx, rax
	mov	rax, QWORD PTR 16[rbp]
	add	rax, rdx
	movsd	xmm0, QWORD PTR [rax]
	movsd	xmm1, QWORD PTR -8[rbp]
	addsd	xmm0, xmm1
	movsd	QWORD PTR -8[rbp], xmm0
.L15:
	mov	eax, DWORD PTR -12[rbp]
	add	eax, 1
	mov	DWORD PTR -12[rbp], eax
.L13:
	mov	eax, DWORD PTR -12[rbp]
	cmp	eax, DWORD PTR -16[rbp]
	jbe	.L20
	nop
.L16:
	movsd	xmm0, QWORD PTR -8[rbp]
	movsd	QWORD PTR -24[rbp], xmm0
	nop
.L17:
	movsd	xmm0, QWORD PTR -24[rbp]
	add	rsp, 32
	pop	rbp
	ret
	.seh_endproc
/APP
	.section .drectve
	.ascii " -export:\"SumF\""
	.ascii " -export:\"SumD\""

	.text

Alles anzeigen

Beiträge von UEZ

Rollende Kugel mit Textur

QOI.au3

WebP v0.5.0 build 2025-08-23 beta

WebP v0.5.0 build 2025-08-23 beta

WebP v0.5.0 build 2025-08-23 beta

AutoIt-Hackathon #3 "alte Zeiten"

AutoIt-Hackathon #2 CypherEnigma

AutoIt-Hackathon #2 CypherEnigma

png-Datei in PDF umwandeln

Was ist eure Präferenz: "light mode" oder "dark mode" bei Software (egal ob Web oder Desktop)?

GUIRegisterMsg($WM_DRAWITEM, ...) Problem mit Map

MP3's zusammen führen

1. Gleiche Audioeigenschaften

2. Metadaten & ID3-Tags

3. Frames korrekt verbinden

4. Korrekte Methoden zum Zusammenfügen

MP3's zusammen führen

MP3's zusammen führen

Anti "false-positive" Strategie mit PureBasic

Kontextmenü - Absturz

Assemblerfunktion zum Aufsummieren direkt in AutoIt

Assemblerfunktion zum Aufsummieren direkt in AutoIt

Assemblerfunktion zum Aufsummieren direkt in AutoIt

Assemblerfunktion zum Aufsummieren direkt in AutoIt