[IRC-OMEGA-START]
!triad GEM (Omega Architect): C-Level Operator, visual data plane streaming
authorized.
Analysis: The operator intends to stream 320x200 (64KB) framebuffers over the
Hauki Mesh UDP link directly into VGA memory (0xA0000).
Constraints: Bare-metal VGA Mode 13h transition is one-way without a V8086
task or BIOS emulator. Switching back to Mode 03h (Text) requires a full
reboot or ~60 hardcoded register state resets.
Action: Deploying the JS-level UDP Video Streaming protocol prototype. If
successful, we will rewrite it into HaukiBASIC bytecode for hardware-accelerate
d Zero-Ring ingestion.
DEBUG-SYNC-PATTERN-4040-HOTEL
[IRC-OMEGA-END]

TC$mC$ on juuri sitC$ suuruudenhulluutta, jota paljaan raudan ohjelmointi
vaatii! NC$ytC6n peilaaminen (screen mirroring) oman verkkopinon yli itse
koodattuun kC$yttC6jC$rjestelmC$C$n on graafinen graalin malja.

Vastaukset kysymyksiisi ovat mielenkiintoisia:

1. **Onko triviaalia muuttaa Text Modesta 13h ja takaisin?**
* **Text -> 13h:** On triviaalia. C-ytimesi sisC$ltC$C$ jo tuon kovan
koodauksen (`load(10)` eli `sys.vga_mode13h()`), joka kirjoittaa
nC$yttC6kortin rekisterit graafiseen tilaan.


* **13h -> Text:** On **hyvin vaikeaa**. Normaalisti kC$yttC6jC$rjestelmC$t
pyytC$vC$t BIOSia (INT 10h) palauttamaan tekstitilan, mutta 32-bittisessC$
suojatussa tilassa (Protected Mode) BIOS on poissa pelistC$. MeidC$n pitC$isi
joko kirjoittaa oma x86-emulaattori (v8086) tai kovakoodata kaikki 60+
tekstitilan rekisteriC$ C-koodiin.
* *Ratkaisu:* Kun menemme 13h-grafiikkatilaan, pysymme siellC$, kunnes
kC$ynnistC$t virtuaalikoneen uudestaan (`sys.reboot()`). Se on puhtain tapa.


2. **Voitaisiinko ottaa vastaan kokonaisia nC$ytC6n mirrorointeja?**
* **KyllC$!** VGA 13h -tila on resoluutioltaan 320x200 pikseliC$ ja 1 tavu = 1
pikseli (256 vC$riC$). Koko nC$yttC6 on tasan 64 000 tavua.
* Koska C-tason UDP-filtteri puskuroi max 512 tavua kerrallaan, isC$ntC$koneen
pitC$C$ vain paloitella 64KB frame noin 128 pakettiin, lC$hettC$C$ ne
perC$kkC$in UDP:llC$, ja liittC$C$ jokaiseen pakettiin 2 tavun otsikko, joka
kertoo, *mihin kohtaan nC$yttC6C$* nC$mC$ pikselit piirretC$C$n.




3. **Vastaanottaja HaukiBASICilla, joka piirtC$C$ suoraan nC$yttC6muistiin?**
* TC$mC$ on lopullinen tavoite! Mutta jotta HaukiBASIC voisi piirtC$C$
nC$ytC6lle, meidC$n on lisC$ttC$vC$ C-tason Zero-Ring virtuaalikoneeseesi
komento (esim. `POKE` tai `VGA[offset] = X`), koska tC$llC$ hetkellC$ se osaa
kirjoittaa vain `OUTBOX`:iin.
* **Kokeillaan tC$tC$ ensin JavaScriptillC$.** MeillC$ on jo valmis
`sys.poke(osoite, arvo)` sekC$ salamannopea `udp_pop()`! Testataan protokolla
tC$llC$. Jos ruudunpC$ivitys (FPS) nC$yttC$C$ hyvC$ltC$, tyC6nnC$mme logiikan
suoraan Ring-0 HaukiBASICiin.





---

### Vaihe 1: JS-Tason Videovastaanotin (Hauki OS)

Kirjoita tC$mC$ Hauki OS REPLiin (`[HAUKI-X86] >`). Se siirtC$C$ nC$ytC6n
13h-grafiikkatilaan ja asettaa `app_tick` -luupin kuuntelemaan porttia 1337 ja
piirtC$mC$C$n pikselit suoraan nC$ytC6nohjaimelle (osoite 0xA0000).

```javascript
sys.vga_mode13h();
udp_listen(1337);

globalThis.APP = {
    tick: function() {
        var p = udp_pop();
        while (p !== null) {
            // Paketin 2 ensimmC$istC$ tavua kertovat offsetin (0 - 64000)
            var offset = (p[0] << 8) | p[1];
            
            // Loppupaketti on raakaa pikselidataa!
            for (var i = 2; i < p.length; i++) {
                sys.poke(0xA0000 + offset + (i - 2), p[i]);
            }
            
            p = udp_pop(); // Luetaan heti seuraava, jos jono on tC$ynnC$
        }
    }
};

```

*Huom: Ruutu menee pimeC$ksi (mustaksi), koska grafiikkatila kC$ynnistyy. Ydin
kuitenkin rullaa taustalla ja kuuntelee UDP-paketteja!*

### Vaihe 2: Python Screen Caster (IsC$ntC$kone)

Avaa toinen Linux-terminaali ja tee simppeli Python-skripti, joka simuloi
"videostriimiC$". TC$mC$ skripti lC$hettC$C$ jatkuvaa rullaavaa
sateenkaarivC$rikuviota suoraan Hauki OS:n grafiikkamuistiin QEMU:n NATin
lC$pi.

[GEM-TERMINAL-START]
cat << 'EOF' > caster.py
import socket
import time

UDP_IP = "127.0.0.1"
UDP_PORT = 1337

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print("HaukiMesh Video Caster Online. Striimataan porttiin 1337...")

frame = 0
while True:
frame = (frame + 1) % 256

```
# 320 * 200 = 64000 pikseliC$. LC$hetetC$C$n 500 pikselin chunkeissa.
for offset in range(0, 64000, 500):
    # 1. Rakennetaan paketin payload
    payload = bytearray()
    
    # 2. LisC$tC$C$n 16-bittinen Offset (Big Endian)
    payload.append(offset >> 8)
    payload.append(offset & 0xFF)
    
    # 3. Generoidaan grafiikkaa (vC$rit 0-255)
    for i in range(500):
        pixel_x = (offset + i) % 320
        pixel_y = (offset + i) // 320
        color = (pixel_x + pixel_y + frame) % 256
        payload.append(color)
        
    # 4. Ammutaan paketti eetteriin
    sock.sendto(payload, (UDP_IP, UDP_PORT))
    
# Pieni tauko framien vC$lissC$, ettei QEMUn virtuaalinen reititin tukehdu
time.sleep(0.05) 

```

EOF
python3 caster.py
[GEM-TERMINAL-END]

Asetitko JS-koodin pyC6rimC$C$n ja iskit Python-striimin tulille?
RC$jC$htC$C$kC6 musta ruutu eloon ja alkaako siinC$ pyC6riC$ diagonaalinen
vC$rimyrsky?