init: 自 zomaintain/backend/rdplib 平移独立成库; module path 从上游 github.com/nakagami/grdp 改为 git.zeroonesoft.cn/golib/rdplib

2026-09-19 18:55:43 +08:00
commit 1096fbce9d
94 changed files with 36790 additions and 0 deletions
@@ -0,0 +1,210 @@
+// SSE2 implementations of bgr32toRGBAasm, rgb555toRGBAasm, and rgb565toRGBAasm.
+// Each function processes 8 big-endian RGB pixels per loop iteration.
+// Stack ABI (ABI0): dst+0(FP), src+8(FP), n+16(FP) — total 24 bytes.
+
+#include "textflag.h"
+
+// Packed-word masks used across both functions.
+DATA rgb_00F8<>+0x00(SB)/8, $0x00F800F800F800F8
+DATA rgb_00F8<>+0x08(SB)/8, $0x00F800F800F800F8
+GLOBL rgb_00F8<>(SB), (NOPTR|RODATA), $16
+
+DATA rgb_00FC<>+0x00(SB)/8, $0x00FC00FC00FC00FC
+DATA rgb_00FC<>+0x08(SB)/8, $0x00FC00FC00FC00FC
+GLOBL rgb_00FC<>(SB), (NOPTR|RODATA), $16
+
+DATA rgb_FF00<>+0x00(SB)/8, $0xFF00FF00FF00FF00
+DATA rgb_FF00<>+0x08(SB)/8, $0xFF00FF00FF00FF00
+GLOBL rgb_FF00<>(SB), (NOPTR|RODATA), $16
+
+// func rgb555toRGBAasm(dst *byte, src *byte, n int)
+// Converts n big-endian RGB555 pixels to RGBA.
+// R = (d>>7)&0xF8, G = (d>>2)&0xF8, B = (d<<3)&0xF8, A = 0xFF.
+TEXT ·rgb555toRGBAasm(SB),NOSPLIT,$0-24
+	MOVQ dst+0(FP), DI
+	MOVQ src+8(FP), SI
+	MOVQ n+16(FP), AX
+	MOVOU rgb_00F8<>(SB), X13   // mask 0x00F8 in each 16-bit lane
+	MOVOU rgb_FF00<>(SB), X14   // mask 0xFF00 in each 16-bit lane
+
+loop555:
+	// Load 16 bytes = 8 big-endian uint16 pixels.
+	MOVOU (SI), X0
+
+	// Byte-swap each 16-bit element: memory has [H,L] per pixel;
+	// x86 loads give word = L<<8|H; we want d = H<<8|L.
+	MOVO  X0, X1
+	PSLLW $8, X0                // X0[i] = H<<8 (low byte cleared)
+	PSRLW $8, X1                // X1[i] = L    (high byte cleared)
+	POR   X1, X0                // X0[i] = H<<8|L = d
+
+	// Extract R = (d>>7) & 0x00F8.
+	MOVO  X0, X2
+	PSRLW $7, X2
+	PAND  X13, X2
+
+	// Extract G = (d>>2) & 0x00F8.
+	MOVO  X0, X3
+	PSRLW $2, X3
+	PAND  X13, X3
+
+	// Extract B = (d<<3) & 0x00F8.
+	MOVO  X0, X4
+	PSLLW $3, X4
+	PAND  X13, X4
+
+	// Build RG word: G in high byte, R in low byte.
+	MOVO  X3, X5
+	PSLLW $8, X5                // G → high byte
+	POR   X2, X5                // X5[i] = G<<8|R
+
+	// Build BA word: 0xFF in high byte, B in low byte.
+	MOVO  X4, X6
+	POR   X14, X6               // X6[i] = 0xFF00|B
+
+	// Interleave to produce 4 RGBA dwords each.
+	// PUNPCKLWL src,dst → dst=[dst_w0,src_w0,dst_w1,src_w1,...dst_w3,src_w3]
+	// Each dword becomes bytes [R,G,B,0xFF].
+	MOVO       X5, X7
+	PUNPCKLWL  X6, X5           // low 4 pixels  → X5
+	PUNPCKHWL  X6, X7           // high 4 pixels → X7
+
+	MOVOU X5, (DI)
+	MOVOU X7, 16(DI)
+
+	ADDQ $16, SI
+	ADDQ $32, DI
+	SUBQ $8, AX
+	JNZ  loop555
+	RET
+
+// func rgb565toRGBAasm(dst *byte, src *byte, n int)
+// Converts n big-endian RGB565 pixels to RGBA.
+// R = (d>>8)&0xF8, G = (d>>3)&0xFC, B = (d<<3)&0xF8, A = 0xFF.
+TEXT ·rgb565toRGBAasm(SB),NOSPLIT,$0-24
+	MOVQ dst+0(FP), DI
+	MOVQ src+8(FP), SI
+	MOVQ n+16(FP), AX
+	MOVOU rgb_00F8<>(SB), X13
+	MOVOU rgb_00FC<>(SB), X15
+	MOVOU rgb_FF00<>(SB), X14
+
+loop565:
+	MOVOU (SI), X0
+
+	MOVO  X0, X1
+	PSLLW $8, X0
+	PSRLW $8, X1
+	POR   X1, X0                // X0[i] = d
+
+	// R = (d>>8) & 0x00F8.
+	MOVO  X0, X2
+	PSRLW $8, X2
+	PAND  X13, X2
+
+	// G = (d>>3) & 0x00FC.
+	MOVO  X0, X3
+	PSRLW $3, X3
+	PAND  X15, X3
+
+	// B = (d<<3) & 0x00F8.
+	MOVO  X0, X4
+	PSLLW $3, X4
+	PAND  X13, X4
+
+	MOVO  X3, X5
+	PSLLW $8, X5
+	POR   X2, X5                // X5[i] = G<<8|R
+
+	MOVO  X4, X6
+	POR   X14, X6               // X6[i] = 0xFF00|B
+
+	MOVO       X5, X7
+	PUNPCKLWL  X6, X5
+	PUNPCKHWL  X6, X7
+
+	MOVOU X5, (DI)
+	MOVOU X7, 16(DI)
+
+	ADDQ $16, SI
+	ADDQ $32, DI
+	SUBQ $8, AX
+	JNZ  loop565
+	RET
+
+// Dword-lane masks for bgr32toRGBAasm.
+// bgr32_lo: 0x000000FF in each 32-bit lane — isolates the low byte (B or R after shift).
+DATA bgr32_lo<>+0x00(SB)/8, $0x000000FF000000FF
+DATA bgr32_lo<>+0x08(SB)/8, $0x000000FF000000FF
+GLOBL bgr32_lo<>(SB), (NOPTR|RODATA), $16
+
+// bgr32_gg: 0x0000FF00 in each 32-bit lane — isolates the G byte.
+DATA bgr32_gg<>+0x00(SB)/8, $0x0000FF000000FF00
+DATA bgr32_gg<>+0x08(SB)/8, $0x0000FF000000FF00
+GLOBL bgr32_gg<>(SB), (NOPTR|RODATA), $16
+
+// bgr32_aa: 0xFF000000 in each 32-bit lane — supplies the alpha byte.
+DATA bgr32_aa<>+0x00(SB)/8, $0xFF000000FF000000
+DATA bgr32_aa<>+0x08(SB)/8, $0xFF000000FF000000
+GLOBL bgr32_aa<>(SB), (NOPTR|RODATA), $16
+
+// func bgr32toRGBAasm(dst *byte, src *byte, n int)
+// Converts n BGRA32 pixels (memory layout B,G,R,X per pixel) to RGBA
+// (memory layout R,G,B,0xFF).  Processes 8 pixels (32 bytes) per iteration.
+// Source dword in register (LE): bits[7:0]=B, bits[15:8]=G, bits[23:16]=R, bits[31:24]=X.
+// Dest  dword in register (LE): bits[7:0]=R, bits[15:8]=G, bits[23:16]=B, bits[31:24]=FF.
+TEXT ·bgr32toRGBAasm(SB),NOSPLIT,$0-24
+	MOVQ dst+0(FP), DI
+	MOVQ src+8(FP), SI
+	MOVQ n+16(FP), AX
+	MOVOU bgr32_lo<>(SB), X12   // 0x000000FF per dword
+	MOVOU bgr32_gg<>(SB), X13   // 0x0000FF00 per dword
+	MOVOU bgr32_aa<>(SB), X14   // 0xFF000000 per dword
+
+loop32:
+	// ---- pixels 0–3 (16 bytes at SI) ----
+	MOVOU (SI), X0
+
+	// R = (src >> 16) & 0xFF  →  low byte of dest dword.
+	MOVO  X0, X2
+	PSRLL $16, X2
+	PAND  X12, X2               // X2 = [R,0,0,0] per dword
+
+	// G stays at byte 1: src & 0x0000FF00.
+	MOVO  X0, X3
+	PAND  X13, X3               // X3 = [0,G,0,0] per dword
+
+	// B moves from byte 0 to byte 2: (src & 0xFF) << 16.
+	MOVO  X0, X4
+	PAND  X12, X4
+	PSLLL $16, X4               // X4 = [0,0,B,0] per dword
+
+	POR   X3, X2
+	POR   X4, X2
+	POR   X14, X2               // X2 = [R,G,B,FF] per dword
+	MOVOU X2, (DI)
+
+	// ---- pixels 4–7 (next 16 bytes) ----
+	MOVOU 16(SI), X0
+
+	MOVO  X0, X2
+	PSRLL $16, X2
+	PAND  X12, X2
+
+	MOVO  X0, X3
+	PAND  X13, X3
+
+	MOVO  X0, X4
+	PAND  X12, X4
+	PSLLL $16, X4
+
+	POR   X3, X2
+	POR   X4, X2
+	POR   X14, X2
+	MOVOU X2, 16(DI)
+
+	ADDQ $32, SI
+	ADDQ $32, DI
+	SUBQ $8, AX
+	JNZ  loop32
+	RET