divaio: Break out Project Diva IO DLL

divaio/divaio.c

@@ -0,0 +1,124 @@
+#include <windows.h>
+
+#include <process.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "divaio/divaio.h"
+
+static unsigned int __stdcall diva_io_slider_thread_proc(void *ctx);
+
+static bool diva_io_coin;
+static uint16_t diva_io_coins;
+static HANDLE diva_io_slider_thread;
+static bool diva_io_slider_stop_flag;
+
+HRESULT diva_io_init(void)
+{
+    return S_OK;
+}
+
+void diva_io_jvs_poll(uint8_t *opbtn_out, uint8_t *gamebtn_out)
+{
+    static const int opbtn_vk[] = { '1', '2' };
+    static const int gamebtn_vk[] = { 'L', 'J', 'F', 'S', ' ' };
+
+    uint8_t opbtn;
+    uint8_t gamebtn;
+    size_t i;
+
+    opbtn = 0;
+    gamebtn = 0;
+
+    for (i = 0 ; i < _countof(opbtn_vk) ; i++) {
+        if (GetAsyncKeyState(opbtn_vk[i]) & 0x8000) {
+            opbtn |= 1 << i;
+        }
+    }
+
+    for (i = 0 ; i < _countof(gamebtn_vk) ; i++) {
+        if (GetAsyncKeyState(gamebtn_vk[i]) & 0x8000) {
+            gamebtn |= 1 << i;
+        }
+    }
+
+    *opbtn_out = opbtn;
+    *gamebtn_out = gamebtn;
+}
+
+uint16_t diva_io_jvs_read_coin_counter(void)
+{
+    if (GetAsyncKeyState('3')) {
+        if (!diva_io_coin) {
+            diva_io_coin = true;
+            diva_io_coins++;
+        }
+    } else {
+        diva_io_coin = false;
+    }
+
+    return diva_io_coins;
+}
+
+void diva_io_jvs_set_coin_blocker(bool open)
+{}
+
+void diva_io_slider_start(diva_io_slider_callback_t callback)
+{
+    if (diva_io_slider_thread != NULL) {
+        return;
+    }
+
+    diva_io_slider_thread = (HANDLE) _beginthreadex(
+            NULL,
+            0,
+            diva_io_slider_thread_proc,
+            callback,
+            0,
+            NULL);
+}
+
+void diva_io_slider_stop(void)
+{
+    diva_io_slider_stop_flag = true;
+
+    WaitForSingleObject(diva_io_slider_thread, INFINITE);
+    CloseHandle(diva_io_slider_thread);
+    diva_io_slider_thread = NULL;
+    diva_io_slider_stop_flag = false;
+}
+
+void diva_io_slider_set_leds(const uint8_t *rgb)
+{}
+
+static unsigned int __stdcall diva_io_slider_thread_proc(void *ctx)
+{
+    static const int keys[] = {
+        'Q', 'W', 'E', 'R', 'U', 'I', 'O', 'P',
+    };
+
+    diva_io_slider_callback_t callback;
+    uint8_t pressure_val;
+    uint8_t pressure[32];
+    size_t i;
+
+    callback = ctx;
+
+    while (!diva_io_slider_stop_flag) {
+        for (i = 0 ; i < 8 ; i++) {
+            if(GetAsyncKeyState(keys[i]) & 0x8000) {
+                pressure_val = 20;
+            } else {
+                pressure_val = 0;
+            }
+
+            memset(&pressure[28 - 4 * i], pressure_val, 4);
+        }
+
+        callback(pressure);
+        Sleep(1);
+    }
+
+    return 0;
+}

divaio/divaio.def

@@ -0,0 +1,10 @@
+LIBRARY divaio
+
+EXPORTS
+    diva_io_init
+    diva_io_jvs_poll
+    diva_io_jvs_read_coin_counter
+    diva_io_jvs_set_coin_blocker
+    diva_io_slider_set_leds
+    diva_io_slider_start
+    diva_io_slider_stop

divaio/divaio.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <windows.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Initialize the Project Diva IO provider DLL. This is the first function to be
+   called on this DLL. Returning failure from this function will cause the main
+   application to immediately exit.
+
+   All subsequent calls may originate from arbitrary threads and some may
+   overlap with each other. Ensuring synchronization inside your IO DLL is
+   your responsibility. */
+
+HRESULT diva_io_init(void);
+
+/* Poll JVS input.
+
+   opbtn returns the cabinet test/service state, where bit 0 is Test and Bit 1
+   is Service.
+
+   gamebtn bits, from least significant to most significant, are:
+
+   Circle Cross Square Triangle Start UNUSED UNUSED UNUSED */
+
+void diva_io_jvs_poll(uint8_t *opbtn, uint8_t *gamebtn);
+
+/* Read the current state of the coin counter. This value should be incremented
+   for every coin detected by the coin acceptor mechanism. This count does not
+   need to persist beyond the lifetime of the process. */
+
+uint16_t diva_io_jvs_read_coin_counter(void);
+
+/* Set the state of the coin blocker. Parameter is true if the blocker is
+   disengaged (i.e. coins can be inserted) and false if the blocker is engaged
+   (i.e. the coin slot should be physically blocked). */
+
+void diva_io_jvs_set_coin_blocker(bool open);
+
+/* Project Diva touch sliders consist of 32 pressure sensitive cells, where
+   cell 1 (array index 0) is the rightmost cell and cell 32 (array index 31) is
+   the leftmost cell. */
+
+/* Callback function supplied to your IO DLL. This must be called with a
+   pointer to a 32-byte array of pressure values, one byte per slider cell.
+   Cells reporting a pressure value of at least 20 are considered to be pressed.
+   This threshold is not configurable.
+
+   The callback will copy the pressure state data out of your buffer before
+   returning. The pointer will not be retained. */
+
+typedef void (*diva_io_slider_callback_t)(const uint8_t *state);
+
+/* Start polling the slider. Your DLL must start a polling thread and call the
+   supplied function periodically from that thread with new input state. The
+   update interval is up to you, but if your input device doesn't have any
+   preferred interval then 1 kHz is a reasonable maximum frequency.
+
+   Note that you do have to have to call the callback "occasionally" even if
+   nothing is changing, otherwise the game will raise a comm timeout error. */
+
+void diva_io_slider_start(diva_io_slider_callback_t callback);
+
+/* Stop polling the slider. You must cease to invoke the input callback before
+   returning from this function.
+
+   This *will* be called in the course of regular operation. For example,
+   every time you go into the operator menu the slider and all of the other I/O
+   on the cabinet gets restarted.
+
+   Following on from the above, the slider polling loop *will* be restarted
+   after being stopped in the course of regular operation. Do not permanently
+   tear down your input driver in response to this function call. */
+
+void diva_io_slider_stop(void);
+
+/* Update the RGB lighting on the slider. A pointer to an array of 32 * 3 = 96
+   bytes is supplied. Layout is probably strictly linear but still TBD. */
+
+void diva_io_slider_set_leds(const uint8_t *rgb);

divaio/meson.build

@@ -0,0 +1,12 @@
+divaio_dll = shared_library(
+    'divaio',
+    name_prefix : '',
+    include_directories : inc,
+    implicit_include_directories : false,
+    vs_module_defs : 'divaio.def',
+    c_pch : '../precompiled.h',
+    sources : [
+        'divaio.c',
+        'divaio.h',
+    ],
+)