Pour moi il était chauve ensuite et gagnait bien sa vie avec la vente de CD... Quelle méprise ! Le gars qui m'a fait enlever les doigts du cul sur un tracker confondu avec un simple vendeur de pop. #Pardon #x1000 💜 #Moby

RE: https://bsky.app/profile/did:plc:q5tj6mrcw36uiybuvttwvmbz/post/3m2rjksbj5c2h

Over the past few weeks I have been working on a blog post looking at AmigaOS 4 updates in 2022 on my AmigaOne X1000. I hope you enjoy it. #amigaone #x1000 #warp3d #amiga #amigaos4
https://www.epsilonsworld.com/2022/12/x1000-amigaos-4-updates-in-2022.html

This implementation is much faster than using flexi-stream.

```Lisp
(defparameter *line-buffer-size* 10)
(defparameter *line-tmp-size* 3)

(defconstant +new-line+ 10)
(defconstant +max-bytes-in-ch+ 4)

(defclass character-input-stream (fundamental-character-input-stream)
((binary-input-stream :accessor binary-input-stream)
(pos :accessor pos :type integer)
(buf-pos :accessor buf-pos :type integer)
(buf :accessor buf)
(buf-len :accessor buf-len)))

(defun read-from-stream (s)
(setf (buf-len s)
(read-sequence (buf s)
(binary-input-stream s))))

(defun new-buf ()
(make-array *line-buffer-size* :fill-pointer t
:element-type '(unsigned-byte 8)))

(defun make-character-input-stream (binary-input-stream)
(let ((s (make-instance 'character-input-stream)))
(setf (binary-input-stream s) binary-input-stream)
(setf (pos s) 0)
(setf (buf-pos s) 0)
(setf (buf s) (new-buf))
(read-from-stream s)
s))

;; (defparameter *line-buffer-size* #x100000)
;; (defparameter *line-tmp-size* #x1000)

(defun new-line-tmp ()
(make-array *line-tmp-size* :fill-pointer 0
:element-type '(unsigned-byte 8)))

(defun end-of-stream? (s)
(eq 0 (buf-len s)))

(defun reset-buf-pos (s)
(setf (buf-pos s) 0))

(defun buf-is-consumed? (s)
(>= (buf-pos s) (buf-len s)))

(defun refill-buffer (s)
(when (buf-is-consumed? s)
(read-from-stream s)
(reset-buf-pos s)))

(defun make-ch-buf ()
(make-array +max-bytes-in-ch+
:fill-pointer 0 :element-type '(unsigned-byte 8)))

(defun read-byte-from-buf (s)
(let ((b (elt (buf s) (buf-pos s))))
(incf (buf-pos s))
(incf (pos s))
b))

(define-condition character-encoding-error (error)
((pos :initarg :pos :reader pos)))

(defun encode-char-1 (s ch-buf)
(declare (ignore s))
(let ((b0 (elt ch-buf 0)))
(when (eq 0 (mask-field (byte 1 7) b0))
(code-char b0))))

(defun encode-char-2 (s ch-buf)
(let ((b0 (elt ch-buf 0))
(b1 (elt ch-buf 1)))
(when (eq #b11000000 (mask-field (byte 3 5) b0))
(when (not (eq #b10000000 (mask-field (byte 2 6) b1)))
(error 'character-encoding-error :pos (pos s)))
(code-char (+ (ash (mask-field (byte 5 0) b0) 6)
(mask-field (byte 6 0) b1))))))

;; (encode-char-2 nil #(#xC2 #xA3))

(defun encode-char-3 (s ch-buf)
(let ((b0 (elt ch-buf 0))
(b1 (elt ch-buf 1))
(b2 (elt ch-buf 2)))
(when (eq #b11100000 (mask-field (byte 4 4) b0))
(when (or (not (eq #b10000000 (mask-field (byte 2 6) b1)))
(not (eq #b10000000 (mask-field (byte 2 6) b2))))
(error 'character-encoding-error :pos (pos s)))
(code-char (+ (mask-field (byte 6 0) b2)
(ash (mask-field (byte 6 0) b1) 6)
(ash (mask-field (byte 4 0) b0) 12))))))

;; (encode-char-3 nil #(224 184 129))

(defun encode-char-4 (s ch-buf)
(let ((b0 (elt ch-buf 0))
(b1 (elt ch-buf 1))
(b2 (elt ch-buf 2))
(b3 (elt ch-buf 3)))
(when (eq #b11110000 (mask-field (byte 5 3) b0))
(when (or (not (eq #b10000000 (mask-field (byte 2 6) b1)))
(not (eq #b10000000 (mask-field (byte 2 6) b2)))
(not (eq #b10000000 (mask-field (byte 2 6) b3))))
(error 'character-encoding-error :pos (pos s)))
(code-char (+ (mask-field (byte 6 0) b3)
(ash (mask-field (byte 6 0) b2) 6)
(ash (mask-field (byte 6 0) b1) 12)
(ash (mask-field (byte 4 0) b0) 18))))))

;; (encode-char-4 nil #(#xF0 #x90 #x8D #x88))

(defun encode-char (s ch-buf)
(let ((ch-buf-len (length ch-buf)))
(case ch-buf-len
(0 nil)
(1 (encode-char-1 s ch-buf))
(2 (encode-char-2 s ch-buf))
(3 (encode-char-3 s ch-buf))
(4 (encode-char-4 s ch-buf))
(otherwise (error 'character-encoding-error :pos (pos s))))))

(defun read-char-from-buf (s)
(let ((ch-buf (make-ch-buf)))
(loop do
(refill-buffer s)
(when (end-of-stream? s)
(return :EOF))
(vector-push (read-byte-from-buf s) ch-buf)
(let ((ch (encode-char s ch-buf)))
(when ch
(return ch))))))

(defmethod stream-read-char ((s character-input-stream))
(read-char-from-buf s))

(defun read-line-from-buf (s)
(let ((line-tmp (new-line-tmp)))
(loop do
(refill-buffer s)
(when (end-of-stream? s)
(return (values (babel:octets-to-string line-tmp :encoding :UTF-8) t)))
(let ((b (read-byte-from-buf s)))
(if (eq b +new-line+)
(return (values (babel:octets-to-string line-tmp :encoding :UTF-8) nil))
(vector-push b line-tmp))))))
```

Even thoough the #AmigaOne #X1000 did not deliver on many of its promises it remains imho one of the most interesting computers built within the last decade. https://amigang.com/amigaone-x1000-10-year-anniversary-thoughts/