FN$="Grayscale"
'---------------------------------
' Atkinson Dithering v 0.94 - Korrigierte Randbehandlung
' Converts PNG Source Files to RGB121 BMP
' by Martin H. 2025 (with the help of the AI assistant)
'---------------------------------
Mode 1
' Read PNG header to determine image size
dim integer w, h
open FN$ + ".png" for input as #1
s$ = INPUT$(24, #1)
' Read width
w=ASC(MID$(s$,17,1))*16777216
inc w,(ASC(MID$(s$,18,1))*65536)
inc w,(ASC(MID$(s$,19,1))*256)
inc w,ASC(MID$(s$,20,1))
' Read height
h=ASC(MID$(s$,21,1))*16777216
inc h,(ASC(MID$(s$,22,1))*65536)
inc h,(ASC(MID$(s$,23,1))*256)
inc h,ASC(MID$(s$,24,1))
close #1

dim integer BL%=(h*w)/64
Dim integer listR(BL%),listG(BL%),listB(BL%)
cls
' Load source image
load png FN$+".png"

' Atkinson ring buffer (starts at index 0, goes up to W+3 for safety)
Dim integer RLine(W+3,3),BLine(W+3,3),GLine(W+3,3)

' ***************************************************************
' START SCAN
' ***************************************************************
for Ypos=0 to H-1
for Xpos=0 to W-1
n=Pixel(Xpos,Ypos)AND &HFFFFFF
R=(N AND 255):G=((N >> 8)AND 255):B=((N >> 16) AND 255)

' -----------------------------------------------------------------
' 1.GREEN (2 bits: 0, 85, 170, 255)
' -----------------------------------------------------------------
GV = G + GLine(Xpos, 1)
' Clipping (Zwischenwert)
if GV > 255 then GV = 255
if GV < 0 then GV = 0

' Quantization to 4 values (step size 85)
Index = INT(GV / 85 + 0.5)
' Palettenwert berechnen
CG = Index * 85
' Since the index is at most 3 (3*85 = 255), no additional clipping is necessary,
' but for robustness we leave it in:
if CG > 255 then CG = 255
GE = GV - CG ' Error is calculated from GV (intermediate value) - CG (pallet value)      GE = GV - CG ' Fehler wird aus GV (Zwischenwert) - CG (Palettenwert) berechnet
' 2.  RED (1 bit: 0 or 255)
' -----------------------------------------------------------------
RV=R+RLine(Xpos,1)
CR=0
if RV>128 then
RE=RV-255:CR=255 ' Error is negative, palette value is 255
else
RE=RV:CR=0 ' Error is positive, pallet value is 0
end if

' -----------------------------------------------------------------
' 3. BLUE (1 bit: 0 or 255)
' -----------------------------------------------------------------
BV=B+BLine(Xpos,1)
CB=0
if BV>128 then
BE=BV-255:CB=255
else
BE=BV:CB=0
end if

'Plot output pixel
Pixel Xpos,Ypos+h,RGB(CR,CG,CB)

' Prepare errors for distribution (1/8 share for all channels)
RE_EIGHT = RE/8
BE_EIGHT = BE/8
GE_EIGHT = GE/8  

' *****************************************************************
' ERROR DISTRIBUTION (Atkinson 1/8 kernel)
' *****************************************************************

' 1. CURRENT LINE (Y) / RLine(F,1)
if Xpos < W-1 then ' (X+1, Y)
inc GLine(Xpos+1,1),GE_EIGHT:inc BLine(Xpos+1,1),BE_EIGHT:inc RLine(Xpos+1,1),RE_EIGHT
end if
if Xpos < W-2 then ' (X+2, Y)
inc GLine(Xpos+2,1),GE_EIGHT:inc BLine(Xpos+2,1),BE_EIGHT:inc RLine(Xpos+2,1),RE_EIGHT
end if

' 2. NEXT LINE (Y+1) / RLine(F,2)
if Ypos < H-1 then ' Only distribute if there is a next line

if Xpos > 0 then ' (X-1, Y+1) - Randprüfung für Index 0
inc GLine(Xpos-1,2),GE_EIGHT:inc BLine(Xpos-1,2),BE_EIGHT:inc RLine(Xpos-1,2),RE_EIGHT
end if
' (X, Y+1)
inc GLine(Xpos,2),GE_EIGHT:inc BLine(Xpos,2),BE_EIGHT:inc RLine(Xpos,2),RE_EIGHT
if Xpos < W-1 then ' (X+1, Y+1)
inc GLine(Xpos+1,2),GE_EIGHT:inc BLine(Xpos+1,2),BE_EIGHT:inc RLine(Xpos+1,2),RE_EIGHT
end if

' 3. NEXT LINE (Y+2) / RLine(F,3)
if Ypos < H-2 then ' Only distribute if there is a line after the next one
' (X, Y+2)
inc GLine(Xpos,3),GE_EIGHT:inc BLine(Xpos,3),BE_EIGHT:inc RLine(Xpos,3),RE_EIGHT
end if

end if
Next

' Next line, scrolling the ring buffer
for f=0 to W+3
RLine(F,1)=RLine(F,2):RLine(F,2)=RLine(F,3):RLine(F,3)=0
BLine(F,1)=BLine(F,2):BLine(F,2)=BLine(F,3):BLine(F,3)=0
GLine(F,1)=GLine(F,2):GLine(F,2)=GLine(F,3):GLine(F,3)=0

Next
Next
save image FN$+".bmp",0,h,w,h