Changeset 67fecc3 in buchla-emu for emu

Timestamp:

09/09/2017 11:11:32 PM (7 years ago)

Author:

Thomas Lopatic <thomas@…>

Branches:

master

Children:

0d83ce8

Parents:

e26a632 (diff), 18cbd53 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Thomas Lopatic <thomas@…> (09/09/2017 11:11:27 PM)

git-committer:

Thomas Lopatic <thomas@…> (09/09/2017 11:11:32 PM)

Message:

Merge LCD emulation.

Location:

emu

Files:

• all.h (modified) (3 diffs)
• kbd.c (modified) (2 diffs)
• lcd.c (modified) (4 diffs)
• sdl.c (modified) (3 diffs)
• vid.c (modified) (1 diff)

emu/all.h

@@ -69 +69 @@
 extern uint32_t vid_win;
 extern uint32_t ser_win;
+extern uint32_t lcd_win;
 
 extern void sdl_init(void);
@@ -113 +114 @@
 extern uint32_t lcd_read(uint32_t off, int32_t sz);
 extern void lcd_write(uint32_t off, int32_t sz, uint32_t val);
+
+extern void lcd_sdl(void);
 
 extern void ser_init(void);
@@ -162 +165 @@
 extern void kbd_write(uint32_t off, int32_t sz, uint32_t val);
 
-extern void kbd_key(SDL_KeyboardEvent *ev, bool dn);
+extern void kbd_key(SDL_KeyboardEvent *ev, bool vid, bool dn);

emu/kbd.c

@@ -104 +104 @@
 }
 
+static void slid(int32_t sig, bool on, int32_t val)
+{
+        out((uint8_t)(0x80 | sig));
+        out(on ? 0x01 : 0x00);
+        out((uint8_t)val);
+}
+
 #if defined NOT_YET
-static void pot_128(int32_t sig, int32_t val)
+static void pot(int32_t sig, int32_t val)
 {
         out((uint8_t)(0x80 | sig));
         out((uint8_t)val);
 }
-
-static void pot_256(int32_t sig, int32_t val)
-{
-        out((uint8_t)(0x80 | sig));
-        out((uint8_t)((val >> 7) & 0x01));
-        out((uint8_t)(val & 0x7f));
-}
 #endif
 
-void kbd_key(SDL_KeyboardEvent *ev, bool dn)
+static void vid_key(SDL_KeyboardEvent *ev, bool dn)
 {
         if ((ev->keysym.mod & KMOD_SHIFT) != 0 &&
@@ -173 +173 @@
 }
 
+static void lcd_key(SDL_KeyboardEvent *ev, bool dn)
+{
+        if ((ev->keysym.mod & KMOD_CTRL) != 0 &&
+                        ev->keysym.sym >= SDLK_a && ev->keysym.sym <= SDLK_n) {
+                int32_t i = ev->keysym.sym - SDLK_a;
+                ver2("kbd lcd %d %s", i, dn ? "dn" : "up");
+
+                if (dn) {
+                        but_on(39 + i);
+                }
+                else {
+                        but_off(39 + i);
+                }
+
+                return;
+        }
+
+        if (ev->keysym.sym >= SDLK_a && ev->keysym.sym <= SDLK_n) {
+                static int32_t lev[14] = {
+                        64, 0, 0, 0, 0, 64, 64, 64, 64, 0, 0, 0, 64, 0
+                };
+
+                int32_t i = ev->keysym.sym - SDLK_a;
+                int32_t val = lev[i];
+
+                if (!dn) {
+                        if ((ev->keysym.mod & KMOD_SHIFT) != 0) {
+                                val = val > 10 ? val - 10 : 0;
+                        }
+                        else {
+                                val = val < 117 ? val + 10 : 127;
+                        }
+                }
+
+                ver2("kbd sli %d %s %d", i, dn ? "dn" : "up", val);
+                slid(25 + i, dn, val);
+
+                lev[i] = val;
+                return;
+        }
+}
+
+void kbd_key(SDL_KeyboardEvent *ev, bool vid, bool dn)
+{
+        if (vid) {
+                vid_key(ev, dn);
+        }
+        else {
+                lcd_key(ev, dn);
+        }
+}
+
 void kbd_init(void)
 {

emu/lcd.c

@@ -24 +24 @@
 int32_t lcd_verbose = 0;
 
+#define WIN_W (1615 * 2 / 3)
+#define WIN_H (304 * 2 / 3)
+
+#define GFX_BGR 0x00000000
+#define GFX_FGR 0xFFFFFFFF
+
+#define TXT_BGR 0x000000FF
+#define TXT_FGR ((SDL_Color){ .r = 255, .b = 255, .g = 255, .a = 255 })
+
+#define REG_ARG 0
+#define REG_COM 1
+
+#define COM_NONE        0x00
+#define COM_MWRITE      0x42
+#define COM_MREAD       0x43
+#define COM_CRSWR       0x46
+#define COM_CRSMRT      0x4C
+#define COM_CRSMUP      0x4E
+#define COM_CRSMDN      0x4F
+#define COM_DSPOFF      0x58
+#define COM_DSPON       0x59
+
+#define TXT_W 85
+#define TXT_H 8
+
+#define GFX_W 85
+#define GFX_H 64
+#define GFX_PIX 6
+
+#define BASE_TXT 0x0000
+#define BASE_GFX 0x2000
+
+#define DIR_UP -85
+#define DIR_DOWN 85
+#define DIR_RIGHT 1
+
+static uint8_t mem_txt[TXT_H * TXT_W];
+static uint8_t mem_gfx[GFX_H * GFX_W];
+
+static SDL_Window *win;
+uint32_t lcd_win;
+
+static SDL_Renderer *ren;
+static SDL_atomic_t frame;
+static SDL_atomic_t ena;
+
+static TTF_Font *fon;
+static int32_t fon_w, fon_h;
+
+static int32_t txt_w, txt_h;
+static SDL_Surface *txt;
+static SDL_Texture *gfx;
+
+static int32_t com;
+static int32_t n_arg;
+static int32_t cur = BASE_TXT;
+static int32_t dir = DIR_RIGHT;
+
+void lcd_sdl(void)
+{
+        ver3("lcd_sdl()");
+
+        static int32_t last = 0;
+        int32_t now = SDL_AtomicGet(&frame);
+
+        if (last == now) {
+                ver3("no update");
+                return;
+        }
+
+        last = now;
+
+        if (SDL_FillRect(txt, NULL, TXT_BGR) < 0) {
+                fail("SDL_FillRect() failed: %s", SDL_GetError());
+        }
+
+        if (SDL_AtomicGet(&ena) == 0) {
+                SDL_Texture *tex = SDL_CreateTextureFromSurface(ren, txt);
+
+                if (tex == NULL) {
+                        fail("SDL_CreateTextureFromSurface() failed: %s", SDL_GetError());
+                }
+
+                if (SDL_RenderCopy(ren, tex, NULL, NULL) < 0) {
+                        fail("SDL_RenderCopy() failed: %s", SDL_GetError());
+                }
+
+                SDL_DestroyTexture(tex);
+                SDL_RenderPresent(ren);
+                return;
+        }
+
+        for (int32_t y = 0; y < TXT_H; ++y) {
+                char line[TXT_W + 1];
+                line[TXT_W] = 0;
+
+                if (SDL_LockMutex(cpu_mutex) < 0) {
+                        fail("SDL_LockMutex() failed: %s", SDL_GetError());
+                }
+
+                memcpy(line, mem_txt + y * TXT_W, TXT_W);
+
+                if (SDL_UnlockMutex(cpu_mutex) < 0) {
+                        fail("SDL_UnlockMutex() failed: %s", SDL_GetError());
+                }
+
+                for (int32_t x = 0; x < TXT_W; ++x) {
+                        if (line[x] == 0x00) {
+                                line[x] = ' ';
+                        }
+                }
+
+                SDL_Surface *lin = TTF_RenderText_Blended(fon, line, TXT_FGR);
+
+                if (lin == NULL) {
+                        fail("TTF_RenderText_Blended() failed: %s", TTF_GetError());
+                }
+
+                if (SDL_BlitSurface(lin, NULL, txt, &(SDL_Rect){
+                        .x = 0,
+                        .y = y * fon_h,
+                        .w = TXT_W * fon_w,
+                        .h = fon_h
+                })) {
+                        fail("SDL_BlitSurface() failed: %s", SDL_GetError());
+                }
+
+                SDL_FreeSurface(lin);
+        }
+
+        SDL_Texture *tex = SDL_CreateTextureFromSurface(ren, txt);
+
+        if (tex == NULL) {
+                fail("SDL_CreateTextureFromSurface() failed: %s", SDL_GetError());
+        }
+
+        if (SDL_RenderCopy(ren, tex, NULL, NULL) < 0) {
+                fail("SDL_RenderCopy() failed: %s", SDL_GetError());
+        }
+
+        SDL_DestroyTexture(tex);
+
+        void *buf;
+        int32_t pitch;
+
+        if (SDL_LockTexture(gfx, NULL, &buf, &pitch) < 0) {
+                fail("SDL_LockTexture() failed: %s", SDL_GetError());
+        }
+
+        uint32_t *pix = buf;
+
+        for (int32_t y = 0; y < GFX_H; ++y) {
+                for (int32_t x = 0; x < GFX_W; ++x) {
+                        uint8_t b = mem_gfx[y * GFX_W + x];
+
+                        for (int32_t p = 0; p < GFX_PIX; ++p) {
+                                bool set = (b & (1 << (7 - p))) != 0;
+                                *pix++ = set ? GFX_FGR : GFX_BGR;
+                        }
+                }
+
+                pix += pitch / 4 - GFX_W * GFX_PIX;
+        }
+
+        SDL_UnlockTexture(gfx);
+
+        if (SDL_RenderCopy(ren, gfx, NULL, NULL) < 0) {
+                fail("SDL_RenderCopy() failed: %s", SDL_GetError());
+        }
+
+        SDL_RenderPresent(ren);
+}
+
 void lcd_init(void)
 {
         ver("lcd init");
+
+        win = SDL_CreateWindow("LCD", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+                        WIN_W, WIN_H, 0);
+
+        if (win == NULL) {
+                fail("SDL_CreateWindow() failed: %s", SDL_GetError());
+        }
+
+        lcd_win = SDL_GetWindowID(win);
+
+        if (lcd_win == 0) {
+                fail("SDL_GetWindowID() failed: %s", SDL_GetError());
+        }
+
+        ren = SDL_CreateRenderer(win, -1, 0);
+
+        if (ren == NULL) {
+                fail("SDL_CreateRenderer() failed: %s", SDL_GetError());
+        }
+
+        gfx = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING,
+                        GFX_W * GFX_PIX, GFX_H);
+
+        if (gfx == NULL) {
+                fail("SDL_CreateTexture() failed: %s", SDL_GetError());
+        }
+
+        if (SDL_SetTextureBlendMode(gfx, SDL_BLENDMODE_BLEND) < 0) {
+                fail("SDL_SetTextureBlendMode() failed: %s", SDL_GetError());
+        }
+
+        SDL_RWops *ops = SDL_RWFromFile(font, "rb");
+
+        if (ops == NULL) {
+                fail("error while opening font file %s: %s", font, SDL_GetError());
+        }
+
+        fon = TTF_OpenFontRW(ops, 1, 32);
+
+        if (fon == NULL) {
+                fail("error while loading font file %s: %s", font, TTF_GetError());
+        }
+
+        fon_h = TTF_FontLineSkip(fon);
+
+        if (TTF_GlyphMetrics(fon, 'X', NULL, NULL, NULL, NULL, &fon_w) < 0) {
+                fail("error while measuring font width: %s", TTF_GetError());
+        }
+
+        txt_w = TXT_W * fon_w;
+        txt_h = TXT_H * fon_h;
+
+        txt = SDL_CreateRGBSurfaceWithFormat(0, txt_w, txt_h, 32, SDL_PIXELFORMAT_RGBA8888);
+
+        if (txt == NULL) {
+                fail("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
+        }
+
+        for (int32_t i = 0; i < TXT_W * TXT_H; ++i) {
+                mem_txt[i] = ' ';
+        }
 }
 
@@ -32 +266 @@
 {
         ver("lcd quit");
+
+        SDL_FreeSurface(txt);
+        TTF_CloseFont(fon);
+
+        SDL_DestroyTexture(gfx);
+
+        SDL_DestroyRenderer(ren);
+        SDL_DestroyWindow(win);
 }
 
@@ -43 +285 @@
 {
         ver2("lcd rd %u:%d", off, sz * 8);
-        return 0;
+
+        if (sz != 1 || off != 1) {
+                fail("invalid lcd rd %u:%d", off, sz * 8);
+        }
+
+        switch (com) {
+        case COM_MREAD:
+                if (cur >= BASE_TXT && cur < BASE_TXT + TXT_W * TXT_H) {
+                        return mem_txt[cur - BASE_TXT];
+                }
+
+                if (cur >= BASE_GFX && cur < BASE_GFX + GFX_W * GFX_H) {
+                        return mem_gfx[cur - BASE_GFX];
+                }
+
+                return 0x00;
+
+        default:
+                return 0x00;
+        }
+}
+
+static void proc_arg(int32_t val)
+{
+        switch (com) {
+        case COM_MWRITE:
+                if (cur >= BASE_TXT && cur < BASE_TXT + TXT_W * TXT_H) {
+                        mem_txt[cur - BASE_TXT] = (uint8_t)val;
+                }
+                else if (cur >= BASE_GFX && cur < BASE_GFX + GFX_W * GFX_H) {
+                        mem_gfx[cur - BASE_GFX] = (uint8_t)val;
+                }
+
+                cur += dir;
+                SDL_AtomicAdd(&frame, 1);
+                break;
+
+        case COM_CRSWR:
+                if (n_arg == 0) {
+                        cur = val;
+                }
+                else if (n_arg == 1) {
+                        cur |= val << 8;
+
+                        if (cur < BASE_TXT ||
+                                        (cur >= BASE_TXT + TXT_W * TXT_H && cur < BASE_GFX) ||
+                                        cur >= BASE_GFX + GFX_W * GFX_H) {
+                                fail("invalid address 0x%04x", cur);
+                        }
+                }
+
+                break;
+
+        default:
+                break;
+        }
+}
+
+static void proc_com(int32_t val)
+{
+        switch (val) {
+        case COM_CRSWR:
+        case COM_MREAD:
+        case COM_MWRITE:
+                com = val;
+                break;
+
+        case COM_CRSMRT:
+                dir = DIR_RIGHT;
+                com = COM_NONE;
+                break;
+
+        case COM_CRSMUP:
+                dir = DIR_UP;
+                com = COM_NONE;
+                break;
+
+        case COM_CRSMDN:
+                dir = DIR_DOWN;
+                com = COM_NONE;
+                break;
+
+        case COM_DSPOFF:
+                SDL_AtomicSet(&ena, 0);
+                com = COM_NONE;
+                break;
+
+        case COM_DSPON:
+                SDL_AtomicSet(&ena, 1);
+                com = COM_NONE;
+                break;
+
+        default:
+                com = COM_NONE;
+                break;
+        }
 }
 
@@ -49 +386 @@
 {
         ver2("lcd wr %u:%d 0x%0*x", off, sz * 8, sz * 2, val);
-}
+
+        if (sz != 1 || off > 1) {
+                fail("invalid lcd wr %u:%d", off, sz * 8);
+        }
+
+        switch (off) {
+        case REG_ARG:
+                proc_arg((int32_t)val);
+                ++n_arg;
+                break;
+
+        case REG_COM:
+                proc_com((int32_t)val);
+                n_arg = 0;
+                break;
+
+        default:
+                break;
+        }
+}

emu/sdl.c

@@ -27 +27 @@
 
 static sdl_func_t sdl_funcs[] = {
-        ser_sdl, vid_sdl
+        lcd_sdl, ser_sdl, vid_sdl
 };
 
@@ -161 +161 @@
                                 }
                                 else if (win == vid_win) {
-                                        kbd_key(&ev.key, true);
+                                        kbd_key(&ev.key, true, true);
+                                }
+                                else if (win == lcd_win) {
+                                        kbd_key(&ev.key, false, true);
                                 }
 
@@ -171 +174 @@
 
                                 if (win == vid_win) {
-                                        kbd_key(&ev.key, false);
+                                        kbd_key(&ev.key, true, false);
+                                }
+                                else if (win == lcd_win) {
+                                        kbd_key(&ev.key, false, false);
                                 }
 

emu/vid.c

@@ -244 +244 @@
         ver("vid init");
 
-        win = SDL_CreateWindow("Display", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+        win = SDL_CreateWindow("Screen", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
                         WIN_W, WIN_H, 0);