├── macos
    └── m8c.app
    │   └── Contents
    │       ├── PkgInfo
    │       ├── Resources
    │           └── m8c.icns
    │       └── Info.plist
├── m8c-nojack.sh
├── .gitignore
├── shell.nix
├── fx_cube.h
├── es_systems.cfg.m8c.paste.txt
├── serial.h
├── write.h
├── ini.h
├── m8c-custom.sh.example
├── midi-connect.sh
├── SDL2_inprint.h
├── render.h
├── list-sdl-controllers.py
├── input.h
├── command.h
├── default.nix
├── m8c-choose.sh
├── config.h
├── m8c.sh
├── config.ini.sample
├── slip.h
├── write.c
├── Makefile
├── LICENSE
├── slip.c
├── fx_cube.c
├── command.c
├── inprint2.c
├── .github
    └── workflows
    │   └── build.yml
├── serial.c
├── AUDIOGUIDE.md
├── inline_font.h.comicsans
├── ini.c
├── inline_font.h
├── render.c
├── main.c
├── config.c
├── input.c
└── README.md


/macos/m8c.app/Contents/PkgInfo:
--------------------------------------------------------------------------------
1 | APPL????
2 | 


--------------------------------------------------------------------------------
/m8c-nojack.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | # start m8 client
4 | pushd /home/pi/code/m8c-piboy
5 | ./m8c
6 | popd
7 | 


--------------------------------------------------------------------------------
/macos/m8c.app/Contents/Resources/m8c.icns:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rasprague/m8c-piboy/HEAD/macos/m8c.app/Contents/Resources/m8c.icns


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.dylib
 2 | *.a
 3 | *.o
 4 | *.exe
 5 | .DS_Store
 6 | m8c
 7 | .vscode
 8 | .cache/
 9 | font.c
10 | build/
11 | compile_commands.json
12 | .clangd
13 | result*
14 | *~
15 | 


--------------------------------------------------------------------------------
/shell.nix:
--------------------------------------------------------------------------------
1 | { pkgs ? import <nixpkgs> {} }:
2 | 
3 | with pkgs;
4 | 
5 | mkShell {
6 |   packages = with pkgs; [ nix-prefetch-github ];
7 |   inputsFrom = [ (import ./default.nix {}).m8c-dev ];
8 | }
9 | 


--------------------------------------------------------------------------------
/fx_cube.h:
--------------------------------------------------------------------------------
1 | #ifndef FX_CUBE_H_
2 | #define FX_CUBE_H_
3 | 
4 | #include "SDL_render.h"
5 | void fx_cube_init(SDL_Renderer *target_renderer, SDL_Color foreground_color);
6 | void fx_cube_destroy();
7 | void fx_cube_update();
8 | #endif


--------------------------------------------------------------------------------
/es_systems.cfg.m8c.paste.txt:
--------------------------------------------------------------------------------
 1 |   <system>
 2 |     <name>m8</name>
 3 |     <fullname>M8 Tracker</fullname>
 4 |     <path>/home/pi/RetroPie/roms/m8</path>
 5 |     <extension>.sh</extension>
 6 |     <command>%ROM%</command>
 7 |     <platform>ignore</platform>
 8 |     <theme>m8</theme>
 9 |   </system>
10 | 


--------------------------------------------------------------------------------
/serial.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #ifndef _SERIAL_H_
 5 | #define _SERIAL_H_
 6 | 
 7 | #include <libserialport.h>
 8 | 
 9 | struct sp_port *init_serial(int verbose);
10 | int check_serial_port(struct sp_port *m8_port);
11 | 
12 | #endif
13 | 


--------------------------------------------------------------------------------
/write.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #ifndef WRITE_H_
 5 | #define WRITE_H_
 6 | 
 7 | #include <stdint.h>
 8 | #include <libserialport.h>
 9 | 
10 | int reset_display(struct sp_port *port);
11 | int enable_and_reset_display(struct sp_port *port);
12 | int disconnect(struct sp_port *port);
13 | int send_msg_controller(struct sp_port *port, uint8_t input);
14 | int send_msg_keyjazz(struct sp_port *port, uint8_t note, uint8_t velocity);
15 | 
16 | #endif


--------------------------------------------------------------------------------
/ini.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Copyright (c) 2016 rxi
 3 |  *
 4 |  * This library is free software; you can redistribute it and/or modify it
 5 |  * under the terms of the MIT license. See `ini.c` for details.
 6 |  */
 7 | 
 8 | #ifndef INI_H
 9 | #define INI_H
10 | 
11 | #define INI_VERSION "0.1.1"
12 | 
13 | typedef struct ini_t ini_t;
14 | 
15 | ini_t*      ini_load(const char *filename);
16 | void        ini_free(ini_t *ini);
17 | const char* ini_get(ini_t *ini, const char *section, const char *key);
18 | int         ini_sget(ini_t *ini, const char *section, const char *key, const char *scanfmt, void *dst);
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/m8c-custom.sh.example:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # set this to the audio interface device number or name
 4 | # you wish to use with m8-headless
 5 | # see output from command aplay -l
 6 | HWAUDIODEVICE=1
 7 | 
 8 | # set this to the sample rate
 9 | RATE=44100
10 | 
11 | # set to 0 to disable audio input, 1 to enable audio input
12 | ENABLEINPUT=0
13 | 
14 | ###############################################################################
15 | OPTIONS=""
16 | 
17 | if [ ENABLEAUDIOINPUT = 1 ]; then
18 |     OPTIONS+=" --enable-input"
19 | fi
20 | 
21 | pushd /home/pi/code/m8c-piboy
22 | ./m8c.sh --interface $HWAUDIODEVICE --rate $RATE $OPTIONS
23 | popd
24 | 


--------------------------------------------------------------------------------
/midi-connect.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # requires naconnect installed at ~/code/naconnect/naconnect
 4 | # $ sudo apt install libncurses-dev
 5 | # $ mkdir -p ~/code && cd ~/code
 6 | # $ git clone https://github.com/dctucker/naconnect.git && cd naconnect
 7 | # $ make
 8 | 
 9 | # button-to-keyboard mappings:
10 | # * cursor keys for axis/dpad
11 | # * c (0x63),d (0x64),q (0x71),TAB (0x09) for buttons 'a','b','x','y'
12 | # * r (0x72),r for buttons lt,rt (shoulder buttons)
13 | #          l    r     u     d    a    b    x    y   lt   rt
14 | params=(0x09 0x09 kcuu1 kcud1 0x63 0x64 0x71 0x09 0x72 0x72)
15 | 
16 | /opt/retropie/admin/joy2key/joy2key start "${params[@]}"
17 | ~/code/naconnect/naconnect
18 | echo "Quitting . . ."
19 | /opt/retropie/admin/joy2key/joy2key stop
20 | echo "Done."
21 | clear
22 | 


--------------------------------------------------------------------------------
/SDL2_inprint.h:
--------------------------------------------------------------------------------
 1 | // Bitmap font routine by driedfruit, https://github.com/driedfruit/SDL_inprint
 2 | // Released into public domain.
 3 | // Modified to support adding a background to text.
 4 | 
 5 | #ifndef SDL2_inprint_h
 6 | #define SDL2_inprint_h
 7 | 
 8 | #include <SDL.h>
 9 | 
10 | extern void prepare_inline_font(void);
11 | extern void kill_inline_font(void);
12 | 
13 | extern void inrenderer(SDL_Renderer *renderer);
14 | extern void infont(SDL_Texture *font);
15 | extern void incolor1(SDL_Color *color);
16 | extern void incolor(Uint32 color, Uint32 unused); /* Color must be in 0x00RRGGBB format ! */
17 | extern void inprint(SDL_Renderer *dst, const char *str, Uint32 x, Uint32 y,
18 |              Uint32 fgcolor, Uint32 bgcolor);
19 | 
20 | extern SDL_Texture *get_inline_font(void);
21 | 
22 | #endif /* SDL2_inprint_h */
23 | 


--------------------------------------------------------------------------------
/render.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #ifndef RENDER_H_
 5 | #define RENDER_H_
 6 | 
 7 | #include "command.h"
 8 | 
 9 | int initialize_sdl(int init_fullscreen, int init_use_gpu);
10 | void close_renderer();
11 | 
12 | int process_queues(struct command_queues *queues);
13 | void draw_waveform(struct draw_oscilloscope_waveform_command *command);
14 | void draw_rectangle(struct draw_rectangle_command *command);
15 | int draw_character(struct draw_character_command *command);
16 | 
17 | void render_screen();
18 | void toggle_fullscreen();
19 | void display_keyjazz_overlay(uint8_t show, uint8_t base_octave, uint8_t velocity);
20 | 
21 | void screensaver_init();
22 | void screensaver_draw();
23 | void screensaver_destroy();
24 | 
25 | #endif
26 | 


--------------------------------------------------------------------------------
/list-sdl-controllers.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Lists controller recognized by SDL
 4 | 
 5 | # Dependency: pygame_sdl2
 6 | # on RetroPie, install with
 7 | # $ sudo apt install python-pygame-sdl2
 8 | 
 9 | import pygame_sdl2 as pygame
10 | 
11 | pygame.controller.init()
12 | pygame.joystick.init()
13 | for i in range(pygame.controller.get_count()):
14 |     c = pygame.controller.Controller(i)
15 |     j = pygame.joystick.Joystick(i)
16 |     j.init()
17 | 
18 |     print "Controller %s" % i
19 |     print "Name:  %s" % j.get_name()
20 |     print "GUID:  %s" % c.get_guid_string()
21 |     print "Num Axes:  %s" % j.get_numaxes()
22 |     print "Num Hats:  %s" % j.get_numhats()
23 |     print "Num Buttons:  %s" % j.get_numbuttons()
24 |     print ""
25 |     c.quit()
26 |     j.quit()
27 | 
28 | pygame.controller.quit()
29 | pygame.joystick.quit()
30 | 


--------------------------------------------------------------------------------
/input.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #ifndef INPUT_H_
 5 | #define INPUT_H_
 6 | 
 7 | #include <stdint.h>
 8 | 
 9 | typedef enum input_buttons_t {
10 |     INPUT_UP,
11 |     INPUT_DOWN,
12 |     INPUT_LEFT,
13 |     INPUT_RIGHT,
14 |     INPUT_OPT,
15 |     INPUT_EDIT,
16 |     INPUT_SELECT,
17 |     INPUT_START,
18 |     INPUT_MAX
19 | } input_buttons_t;
20 | 
21 | typedef enum input_type_t {
22 |   normal,
23 |   keyjazz,
24 |   special
25 | } input_type_t;
26 | 
27 | typedef enum special_messages_t {
28 |   msg_quit = 1,
29 |   msg_reset_display = 2
30 | } special_messages_t;
31 | 
32 | typedef struct input_msg_s {
33 |   input_type_t type;
34 |   uint8_t value;
35 |   uint8_t value2;
36 |   uint32_t eventType;
37 | } input_msg_s;
38 | 
39 | int initialize_game_controllers();
40 | void close_game_controllers();
41 | input_msg_s get_input_msg();
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/command.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #ifndef COMMAND_H_
 5 | #define COMMAND_H_
 6 | 
 7 | #include <stdint.h>
 8 | 
 9 | struct position {
10 |   uint16_t x;
11 |   uint16_t y;
12 | };
13 | 
14 | struct size {
15 |   uint16_t width;
16 |   uint16_t height;
17 | };
18 | 
19 | struct color {
20 |   uint8_t r;
21 |   uint8_t g;
22 |   uint8_t b;
23 | };
24 | 
25 | struct draw_rectangle_command {
26 |   struct position pos;
27 |   struct size size;
28 |   struct color color;
29 | };
30 | 
31 | struct draw_character_command {
32 |   int c;
33 |   struct position pos;
34 |   struct color foreground;
35 |   struct color background;
36 | };
37 | 
38 | struct draw_oscilloscope_waveform_command {
39 |   struct color color;
40 |   uint8_t waveform[320];
41 |   uint16_t waveform_size;
42 | };
43 | 
44 | struct command_queues {
45 |   struct draw_rectangle_command rectangles[128];
46 |   uint8_t rectangles_queue_size;
47 |   struct draw_character_command characters[128];
48 |   uint8_t characters_queue_size;
49 |   struct draw_oscilloscope_waveform_command waveform;
50 |   uint8_t waveforms_queue_size;
51 | };
52 | 
53 | 
54 | int process_command(uint8_t *data, uint32_t size);
55 | 
56 | #endif


--------------------------------------------------------------------------------
/default.nix:
--------------------------------------------------------------------------------
 1 | { pkgs ? import <nixpkgs> {} }:
 2 | 
 3 | with pkgs;
 4 | 
 5 | # HOWTO keep this package definition up-to-date:
 6 | #
 7 | # 1. NEW VERSION:
 8 | # After the new version is tagged and pushed, update the `version` var to the
 9 | # proper value and update the hash. You can use the following command to find
10 | # out the sha256, for example, with version 1.0.3:
11 | # `nix-prefetch-github --rev v1.0.3 laamaa m8c`
12 | #
13 | # 2. NEW DEPENDENCIES:
14 | # Make sure new dependencies are added. Runtime deps go to buildInputs and
15 | # compile-time deps go to nativeBuildInputs. Use the nixpkgs manual for help
16 | #
17 | let m8c-package =
18 |   { stdenv
19 |   , gnumake
20 |   , SDL2
21 |   , libserialport
22 |   , fetchFromGitHub
23 |   }:
24 | 
25 |   let
26 |     pname = "m8c";
27 |     version = "1.0.3";
28 |   in
29 |     stdenv.mkDerivation {
30 |       inherit pname version;
31 | 
32 |       src = fetchFromGitHub {
33 |         owner = "laamaa";
34 |         repo = pname;
35 |         rev = "v${version}";
36 |         hash = "sha256:0yrd6lnb2chgafhw1cz4awx2s1sws6mch5irvgyddgnsa8ishcr5";
37 |       };
38 | 
39 |       installFlags = [ "PREFIX=$(out)" ];
40 |       nativeBuildInputs = [ gnumake ];
41 |       buildInputs = [ SDL2 libserialport ];
42 |     };
43 | in {
44 |   m8c-stable = pkgs.callPackage m8c-package {};
45 |   m8c-dev = (pkgs.callPackage m8c-package {}).overrideAttrs (oldAttrs: {src = ./.;});
46 | }
47 | 


--------------------------------------------------------------------------------
/m8c-choose.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | function joy2key_start {
 4 |     echo "Starting joy2key . . ."
 5 |     /opt/retropie/admin/joy2key/joy2key start
 6 | }
 7 | 
 8 | function joy2key_stop {
 9 |     echo "Stopping joy2key . . ."
10 |     /opt/retropie/admin/joy2key/joy2key stop
11 | }
12 | 
13 | trap joy2key_stop EXIT
14 | 
15 | CARDCMD="dialog --stdout --title \"m8-headless tracker client\" --menu \"Choose an Audio Interface\" 20 80 20"
16 | RATECMD="dialog --stdout --title \"m8-headless tracker client\" --menu \"Choose a Sample Rate\" 10 30 20 0 44.1kHz 1 48kHz"
17 | AUDIOINCMD="dialog --stdout --title \"m8-headless tracker client\" --defaultno --yesno \"Enable Audio Input?\" 6 25"
18 | 
19 | CARDLIST=""
20 | OPTIONS=""
21 | I=0
22 | 
23 | OUTPUT=$(aplay -l | grep ^card)
24 | while read line; do
25 |     CARDLIST="$CARDLIST $I \"$line\""
26 |     ((I=I+1))
27 | done <<< "$OUTPUT"
28 | 
29 | joy2key_start
30 | CARD=$(eval $CARDCMD $CARDLIST)
31 | [ $? != 0 ] && echo "Cancelled." && exit 1
32 | 
33 | RATE=$(eval $RATECMD)
34 | [ $? != 0 ] && echo "Cancelled." && exit 1
35 | if [ $RATE = 0 ]; then
36 |     RATE=44100
37 | elif [ $RATE = 1 ]; then
38 |     RATE=48000
39 | fi
40 | 
41 | eval $AUDIOINCMD
42 | case $? in
43 |     # yes
44 |     0) OPTIONS+=" --enable-input" ;;
45 |     # no
46 |     1) ;;
47 |     # [ESC]
48 |     255) echo "Cancelled." ; exit 1 ;;
49 | esac    
50 | joy2key_stop
51 | 
52 | pushd /home/pi/code/m8c-piboy
53 | echo ./m8c.sh --interface $CARD --rate $RATE $OPTIONS
54 | ./m8c.sh --interface $CARD --rate $RATE $OPTIONS
55 | popd
56 | 


--------------------------------------------------------------------------------
/config.h:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #ifndef CONFIG_H_
 5 | #define CONFIG_H_
 6 | 
 7 | #include "ini.h"
 8 | 
 9 | typedef struct config_params_s {
10 |   char *filename;
11 |   int init_fullscreen;
12 |   int init_use_gpu;
13 |   int init_disable_cursor;
14 |   int idle_ms;
15 |   int wait_for_device;
16 |   int wait_packets;
17 | 
18 |   int key_up;
19 |   int key_left;
20 |   int key_down;
21 |   int key_right;
22 |   int key_select;
23 |   int key_select_alt;
24 |   int key_start;
25 |   int key_start_alt;
26 |   int key_opt;
27 |   int key_opt_alt;
28 |   int key_edit;
29 |   int key_edit_alt;
30 |   int key_delete;
31 |   int key_reset;
32 | 
33 |   int gamepad_up;
34 |   int gamepad_left;
35 |   int gamepad_down;
36 |   int gamepad_right;
37 |   int gamepad_select;
38 |   int gamepad_start;
39 |   int gamepad_opt;
40 |   int gamepad_edit;
41 |   int gamepad_quit;
42 |   int gamepad_reset;
43 | 
44 |   int gamepad_analog_threshold;
45 |   int gamepad_analog_invert;
46 |   int gamepad_analog_axis_updown;
47 |   int gamepad_analog_axis_leftright;
48 |   int gamepad_analog_axis_start;
49 |   int gamepad_analog_axis_select;
50 |   int gamepad_analog_axis_opt;
51 |   int gamepad_analog_axis_edit;
52 | 
53 | } config_params_s;
54 | 
55 | 
56 | config_params_s init_config();
57 | void read_config();
58 | void read_graphics_config(ini_t *config, config_params_s *conf);
59 | void read_key_config(ini_t *config, config_params_s *conf);
60 | void read_gamepad_config(ini_t *config, config_params_s *conf);
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/m8c.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | HWAUDIODEVICE=0
 4 | ENABLEINPUT=0
 5 | RATE=44100
 6 | 
 7 | usage()
 8 | {
 9 |     echo "Usage $0"
10 |     echo "  options:"
11 |     echo "    [ -i | --interface ] <I> - use audio interface I, defaults to 0"
12 |     echo "      (see output from aplay -l command)"
13 |     echo "    [ -r | --rate ] <R> - use R sample rate, defaults to 44100"
14 |     echo "    [ -e | --enable-input = enable audio input, defaults is off"
15 |     echo "    [ -h | --help ] show this helpful message"
16 | }
17 | 
18 | OPTIONS=$(getopt -o i:r:eh --long interface:,rate:,enable-input,help -- "$@")
19 | if [ $? -ne 0 ]; then
20 |     usage
21 |     exit 1
22 | fi
23 | 
24 | eval set -- "$OPTIONS"
25 | 
26 | while true; do
27 |     case "$1" in
28 | 	-i|--interface)
29 | 	    HWAUDIODEVICE=$2 ; shift 2 ;;
30 | 	-r|--rate)
31 | 	    RATE=$2 ; shift 2 ;;
32 | 	-e|--enable-input)
33 | 	    ENABLEINPUT=1 ; shift ;;
34 | 	-h|--help)
35 | 	    usage ; shift ; exit 0 ;;
36 | 	--)
37 | 	    shift ; break ;;
38 |     esac
39 | done
40 | 
41 | # audio routing
42 | export JACK_NO_AUDIO_RESERVATION=1
43 | jackd -d alsa -d hw:M8 -r$RATE -p512 &
44 | sleep 1
45 | 
46 | # setup output
47 | alsa_out -j m8out -d hw:$HWAUDIODEVICE -r $RATE &
48 | sleep 1
49 | jack_connect system:capture_1 m8out:playback_1
50 | jack_connect system:capture_2 m8out:playback_2
51 | 
52 | # setup input
53 | if [ $ENABLEINPUT -eq 1 ]; then
54 |   alsa_in -j m8in -d hw:$HWAUDIODEVICE -r $RATE &
55 |   sleep 1
56 |   jack_connect m8in:capture_1 system:playback_1
57 |   jack_connect m8in:capture_2 system:playback_2
58 | fi
59 | 
60 | # start m8 client
61 | pushd /home/pi/code/m8c-piboy
62 | ./m8c
63 | popd
64 | 
65 | # clean up audio routing
66 | killall -s SIGINT jackd alsa_out alsa_in
67 | 


--------------------------------------------------------------------------------
/macos/m8c.app/Contents/Info.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>BuildMachineOSBuild</key>
 6 | 	<string>17G11023</string>
 7 | 	<key>CFBundleDevelopmentRegion</key>
 8 | 	<string>en</string>
 9 | 	<key>CFBundleIconFile</key>
10 | 	<string>m8c</string>
11 | 	<key>CFBundleExecutable</key>
12 | 	<string>m8c</string>
13 | 	<key>CFBundleIdentifier</key>
14 | 	<string>com.laamaa.m8c</string>
15 | 	<key>CFBundleInfoDictionaryVersion</key>
16 | 	<string>6.0</string>
17 | 	<key>CFBundleName</key>
18 | 	<string>m8c</string>
19 | 	<key>CFBundlePackageType</key>
20 | 	<string>APPL</string>
21 | 	<key>CFBundleShortVersionString</key>
22 | 	<string>1.0</string>
23 | 	<key>CFBundleSupportedPlatforms</key>
24 | 	<array>
25 | 		<string>MacOSX</string>
26 | 	</array>
27 | 	<key>CFBundleVersion</key>
28 | 	<string>1</string>
29 | 	<key>DTCompiler</key>
30 | 	<string>com.apple.compilers.llvm.clang.1_0</string>
31 | 	<key>DTPlatformBuild</key>
32 | 	<string>10B61</string>
33 | 	<key>DTPlatformVersion</key>
34 | 	<string>GM</string>
35 | 	<key>DTSDKBuild</key>
36 | 	<string>18B71</string>
37 | 	<key>DTSDKName</key>
38 | 	<string>macosx10.14</string>
39 | 	<key>DTXcode</key>
40 | 	<string>1010</string>
41 | 	<key>DTXcodeBuild</key>
42 | 	<string>10B61</string>
43 | 	<key>LSApplicationCategoryType</key>
44 | 	<string>public.app-category.utilities</string>
45 | 	<key>LSMinimumSystemVersion</key>
46 | 	<string>10.13</string>
47 | 	<key>NSHumanReadableCopyright</key>
48 | 	<string>Copyright © 2021 laamaa. All rights reserved.</string>
49 | 	<key>NSMainNibFile</key>
50 | 	<string>MainMenu</string>
51 | 	<key>NSPrincipalClass</key>
52 | 	<string>NSApplication</string>
53 | </dict>
54 | </plist>
55 | 


--------------------------------------------------------------------------------
/config.ini.sample:
--------------------------------------------------------------------------------
 1 | ; edit this file to change m8c defaults
 2 | ; this file is re-written every time it is read,
 3 | ; so do not expect comments or commented out values to survive!
 4 | ; valid parameter changes will be written back and persisted though.
 5 | 
 6 | [graphics]
 7 | ; set this to true to have m8c start fullscreen
 8 | fullscreen=false
 9 | ; set this to false to run m8c in software rendering mode (may be useful for Raspberry Pi)
10 | use_gpu=true
11 | ; set this to true to disable the mouse cursor at startup
12 | diable_cursor=false
13 | ; the delay amount in ms in the main loop, decrease value for faster operation, increase value if too much cpu usage
14 | idle_ms = 10
15 | ; show a spinning cube if device is not inserted
16 | wait_for_device = true
17 | ; number of zero-byte attempts to disconnect if wait_for_device = false (128 = about 2 sec for default idle_ms)
18 | wait_packets = 128
19 | 
20 | [keyboard]
21 | ; these need to be the decimal value of the SDL scancodes.
22 | ; a table exists here: https://github.com/libsdl-org/sdlwiki/blob/main/SDLScancodeLookup.mediawiki
23 | key_up=82
24 | key_left=80
25 | key_down=81
26 | key_right=79
27 | key_select=225
28 | key_select_alt=4
29 | key_start=44
30 | key_start_alt=22
31 | key_opt=226
32 | key_opt_alt=29
33 | key_edit=224
34 | key_edit_alt=27
35 | key_delete=76
36 | key_reset=21
37 | 
38 | [gamepad]
39 | ; these need to be the decimal value of the SDL Controller buttons.
40 | ; a table exists here: https://wiki.libsdl.org/SDL_GameControllerButton
41 | gamepad_up=11
42 | gamepad_left=13
43 | gamepad_down=12
44 | gamepad_right=14
45 | gamepad_select=4
46 | gamepad_start=6
47 | gamepad_opt=1
48 | gamepad_edit=0
49 | gamepad_quit=8
50 | gamepad_reset=7
51 | 
52 | gamepad_analog_threshold=32766 ;the threshold for analog sticks to trigger cursor movement (working values: 1-32766)
53 | gamepad_analog_invert=false ;NOT IMPLEMENTED YET: invert up/down and left/right axis (true/false)
54 | 
55 | ; these need to be the decimal value of the controller axis
56 | ; you can use -1 if you do not wish to map the function to an analog axis
57 | gamepad_analog_axis_updown=1
58 | gamepad_analog_axis_leftright=0
59 | gamepad_analog_axis_start=5
60 | gamepad_analog_axis_select=4
61 | gamepad_analog_axis_opt=-1
62 | gamepad_analog_axis_edit=-1
63 | 


--------------------------------------------------------------------------------
/slip.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | MIT License
 3 | 
 4 | Copyright (c) 2018 Marcin Borowicz
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | */
24 | 
25 | /* This code is originally by marcinbor85, https://github.com/marcinbor85/slip
26 | It has been simplified a bit as CRC checking etc. is not required in this
27 | program. */
28 | 
29 | #ifndef SLIP_H_
30 | #define SLIP_H_
31 | 
32 | #include "command.h"
33 | #include <stdint.h>
34 | 
35 | #define SLIP_SPECIAL_BYTE_END           0xC0
36 | #define SLIP_SPECIAL_BYTE_ESC           0xDB
37 | 
38 | #define SLIP_ESCAPED_BYTE_END           0xDC
39 | #define SLIP_ESCAPED_BYTE_ESC           0xDD
40 | 
41 | typedef enum {
42 |         SLIP_STATE_NORMAL = 0x00,
43 |         SLIP_STATE_ESCAPED
44 | } slip_state_t;
45 | 
46 | typedef struct {
47 |         uint8_t *buf;
48 |         uint32_t buf_size;
49 |         int (*recv_message)(uint8_t *data, uint32_t size);
50 | } slip_descriptor_s;
51 | 
52 | typedef struct {
53 |         slip_state_t state;
54 |         uint32_t size;
55 |         const slip_descriptor_s *descriptor;
56 | } slip_handler_s;
57 | 
58 | typedef enum {
59 |         SLIP_NO_ERROR = 0x00,
60 |         SLIP_ERROR_BUFFER_OVERFLOW,
61 |         SLIP_ERROR_UNKNOWN_ESCAPED_BYTE,
62 |         SLIP_ERROR_INVALID_PACKET
63 | } slip_error_t;
64 | 
65 | slip_error_t slip_init(slip_handler_s *slip, const slip_descriptor_s *descriptor);
66 | slip_error_t slip_read_byte(slip_handler_s *slip, uint8_t byte);
67 | 
68 | #endif


--------------------------------------------------------------------------------
/write.c:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 Jonne Kokkonen
 2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
 3 | 
 4 | #include "SDL_timer.h"
 5 | #include <SDL_log.h>
 6 | #include <libserialport.h>
 7 | #include <stdint.h>
 8 | #include <stdio.h>
 9 | #include <unistd.h>
10 | 
11 | int reset_display(struct sp_port *port) {
12 |   SDL_Log("Reset display\n");
13 |   uint8_t buf[2];
14 |   int result;
15 | 
16 |   buf[0] = 0x45;
17 |   buf[1] = 0x52;
18 | 
19 |   result = sp_blocking_write(port, buf, 2, 5);
20 |   if (result != 2) {
21 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error resetting M8 display, code %d",
22 |                  result);
23 |     return 0;
24 |   }
25 |   return 1;
26 | }
27 | 
28 | int enable_and_reset_display(struct sp_port *port) {
29 |   uint8_t buf[1];
30 |   int result;
31 | 
32 |   SDL_Log("Enabling and resetting M8 display\n");
33 | 
34 |   buf[0] = 0x44;
35 |   result = sp_blocking_write(port, buf, 1, 5);
36 |   if (result != 1) {
37 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error enabling M8 display, code %d",
38 |                  result);
39 |     return 0;
40 |   }
41 | 
42 |   SDL_Delay(5);
43 |   result = reset_display(port);
44 |   if (result == 1)
45 |     return 1;
46 |   else
47 |     return 0;
48 | }
49 | 
50 | int disconnect(struct sp_port *port) {
51 |   char buf[1] = {'D'};
52 |   int result;
53 | 
54 |   SDL_Log("Disconnecting M8\n");
55 | 
56 |   result = sp_blocking_write(port, buf, 1, 5);
57 |   if (result != 1) {
58 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error sending disconnect, code %d",
59 |                  result);
60 |     return -1;
61 |   }
62 |   return 1;
63 | }
64 | 
65 | int send_msg_controller(struct sp_port *port, uint8_t input) {
66 |   char buf[2] = {'C', input};
67 |   size_t nbytes = 2;
68 |   int result;
69 |   result = sp_blocking_write(port, buf, nbytes, 5);
70 |   if (result != nbytes) {
71 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error sending input, code %d",
72 |                  result);
73 |     return -1;
74 |   }
75 |   return 1;
76 | }
77 | 
78 | int send_msg_keyjazz(struct sp_port *port, uint8_t note, uint8_t velocity) {
79 |   if (velocity > 0x7F)
80 |     velocity = 0x7F;
81 |   char buf[3] = {'K', note, velocity};
82 |   size_t nbytes = 3;
83 |   int result;
84 |   result = sp_blocking_write(port, buf, nbytes, 5);
85 |   if (result != nbytes) {
86 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Error sending keyjazz, code %d",
87 |                  result);
88 |     return -1;
89 |   }
90 | 
91 |   return 1;
92 | }
93 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | #Set all your object files (the object files of all the .c files in your project, e.g. main.o my_sub_functions.o )
 2 | OBJ = main.o serial.o slip.o command.o write.o render.o ini.o config.o input.o font.o fx_cube.o
 3 | 
 4 | #Set any dependant header files so that if they are edited they cause a complete re-compile (e.g. main.h some_subfunctions.h some_definitions_file.h ), or leave blank
 5 | DEPS = serial.h slip.h command.h write.h render.h ini.h config.h input.h fx_cube.h
 6 | 
 7 | #Any special libraries you are using in your project (e.g. -lbcm2835 -lrt `pkg-config --libs gtk+-3.0` ), or leave blank
 8 | INCLUDES = $(shell pkg-config --libs sdl2 libserialport)
 9 | 
10 | 
11 | 
12 | #Set any compiler flags you want to use (e.g. -I/usr/include/somefolder `pkg-config --cflags gtk+-3.0` ), or leave blank
13 | local_CFLAGS = $(CFLAGS) $(shell pkg-config --cflags sdl2 libserialport) -Wall -O2 -pipe -I.
14 | 
15 | #Set the compiler you are using ( gcc for C or g++ for C++ )
16 | CC = gcc
17 | 
18 | #Set the filename extensiton of your C files (e.g. .c or .cpp )
19 | EXTENSION = .c
20 | 
21 | #define a rule that applies to all files ending in the .o suffix, which says that the .o file depends upon the .c version of the file and all the .h files included in the DEPS macro.  Compile each object file
22 | %.o: %$(EXTENSION) $(DEPS)
23 | 	$(CC) -c -o $@ $< $(local_CFLAGS)
24 | 
25 | #Combine them into the output file
26 | #Set your desired exe output file name here
27 | m8c: $(OBJ)
28 | 	$(CC) -o $@ $^ $(local_CFLAGS) $(INCLUDES)
29 | 
30 | font.c: inline_font.h
31 | 	@echo "#include <SDL.h>" > $@-tmp1
32 | 	@cat inline_font.h >> $@-tmp1
33 | 	@cat inprint2.c > $@-tmp2
34 | 	@sed '/#include/d' $@-tmp2 >> $@-tmp1
35 | 	@rm $@-tmp2
36 | 	@mv $@-tmp1 $@
37 | 	@echo "[~cat] inline_font.h inprint2.c > font.c"
38 | #	$(CC) -c -o font.o font.c $(local_CFLAGS)
39 | 
40 | font.c: inline_font.h
41 | 	@echo "#include <SDL.h>" > $@-tmp1
42 | 	@cat inline_font.h >> $@-tmp1
43 | 	@cat inprint2.c > $@-tmp2
44 | 	@sed '/#include/d' $@-tmp2 >> $@-tmp1
45 | 	@rm $@-tmp2
46 | 	@mv $@-tmp1 $@
47 | 	@echo "[~cat] inline_font.h inprint2.c > font.c"
48 | #	$(CC) -c -o font.o font.c $(CFLAGS)
49 | 
50 | #Cleanup
51 | .PHONY: clean
52 | 
53 | clean:
54 | 	rm -f *.o *~ m8c *~ font.c
55 | 
56 | # PREFIX is environment variable, but if it is not set, then set default value
57 | ifeq ($(PREFIX),)
58 |     PREFIX := /usr/local
59 | endif
60 | 
61 | install: m8c
62 | 	install -d $(DESTDIR)$(PREFIX)/bin/
63 | 	install -m 755 m8c $(DESTDIR)$(PREFIX)/bin/
64 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Jonne Kokkonen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | -----------
24 | 
25 | The software contains a SLIP command processing routine by Marcin Borowicz (slip.c, slip.h):
26 | 
27 | MIT License
28 | 
29 | Copyright (c) 2018 Marcin Borowicz
30 | 
31 | Permission is hereby granted, free of charge, to any person obtaining a copy
32 | of this software and associated documentation files (the "Software"), to deal
33 | in the Software without restriction, including without limitation the rights
34 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
35 | copies of the Software, and to permit persons to whom the Software is
36 | furnished to do so, subject to the following conditions:
37 | 
38 | The above copyright notice and this permission notice shall be included in all
39 | copies or substantial portions of the Software.
40 | 
41 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
42 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
43 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
44 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
45 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
46 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
47 | SOFTWARE.
48 | 
49 | -----------
50 | 
51 | The software contains a bitmap font rendered from Trash80's original work, https://fontstruct.com/fontstructions/show/413734/stealth57.
52 | The font (embedded in inline_font.h) is originally licensed under CC-BY-SA 3.0, https://creativecommons.org/licenses/by-sa/3.0/.
53 | The font is used in this program with the permission of the original author.
54 | 
55 | -----------
56 | 
57 | The software contains portions of public domain code:
58 | Bitmap font routine by driedfruit, https://github.com/driedfruit/SDL_inprint (SDL2_inprint.h, inprint2.c)
59 | Serial port code from libserialport's examples (serial.c, serial.h)
60 | 
61 | -----------
62 | 
63 | The software contains the Tiny ANSI C ini libary under The MIT License:
64 | rxi: https://github.com/rxi/ini (ini.h, ini.c)


--------------------------------------------------------------------------------
/slip.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | MIT License
  3 | 
  4 | Copyright (c) 2018 Marcin Borowicz
  5 | 
  6 | Permission is hereby granted, free of charge, to any person obtaining a copy
  7 | of this software and associated documentation files (the "Software"), to deal
  8 | in the Software without restriction, including without limitation the rights
  9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 | copies of the Software, and to permit persons to whom the Software is
 11 | furnished to do so, subject to the following conditions:
 12 | 
 13 | The above copyright notice and this permission notice shall be included in all
 14 | copies or substantial portions of the Software.
 15 | 
 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 22 | SOFTWARE.
 23 | */
 24 | 
 25 | /* This code is originally by marcinbor85, https://github.com/marcinbor85/slip
 26 | It has been simplified a bit as CRC checking etc. is not required in this
 27 | program. */
 28 | 
 29 | #include "slip.h"
 30 | #include "command.h"
 31 | 
 32 | #include <assert.h>
 33 | #include <stddef.h>
 34 | 
 35 | static void reset_rx(slip_handler_s *slip) {
 36 |   assert(slip != NULL);
 37 | 
 38 |   slip->state = SLIP_STATE_NORMAL;
 39 |   slip->size = 0;
 40 | }
 41 | 
 42 | slip_error_t slip_init(slip_handler_s *slip,
 43 |                        const slip_descriptor_s *descriptor) {
 44 |   assert(slip != NULL);
 45 |   assert(descriptor != NULL);
 46 |   assert(descriptor->buf != NULL);
 47 |   assert(descriptor->recv_message != NULL);
 48 | 
 49 |   slip->descriptor = descriptor;
 50 |   reset_rx(slip);
 51 | 
 52 |   return SLIP_NO_ERROR;
 53 | }
 54 | 
 55 | static slip_error_t put_byte_to_buffer(slip_handler_s *slip, uint8_t byte) {
 56 |   slip_error_t error = SLIP_NO_ERROR;
 57 | 
 58 |   assert(slip != NULL);
 59 | 
 60 |   if (slip->size >= slip->descriptor->buf_size) {
 61 |     error = SLIP_ERROR_BUFFER_OVERFLOW;
 62 |     reset_rx(slip);
 63 |   } else {
 64 |     slip->descriptor->buf[slip->size++] = byte;
 65 |     slip->state = SLIP_STATE_NORMAL;
 66 |   }
 67 | 
 68 |   return error;
 69 | }
 70 | 
 71 | slip_error_t slip_read_byte(slip_handler_s *slip, uint8_t byte) {
 72 |   slip_error_t error = SLIP_NO_ERROR;
 73 | 
 74 |   assert(slip != NULL);
 75 | 
 76 |   switch (slip->state) {
 77 |   case SLIP_STATE_NORMAL:
 78 |     switch (byte) {
 79 |     case SLIP_SPECIAL_BYTE_END:
 80 |       if (!slip->descriptor->recv_message(slip->descriptor->buf, slip->size)){
 81 |         error = SLIP_ERROR_INVALID_PACKET;
 82 |       }
 83 |       reset_rx(slip);
 84 |       break;
 85 |     case SLIP_SPECIAL_BYTE_ESC:
 86 |       slip->state = SLIP_STATE_ESCAPED;
 87 |       break;
 88 |     default:
 89 |       error = put_byte_to_buffer(slip, byte);
 90 |       break;
 91 |     }
 92 |     break;
 93 | 
 94 |   case SLIP_STATE_ESCAPED:
 95 |     switch (byte) {
 96 |     case SLIP_ESCAPED_BYTE_END:
 97 |       byte = SLIP_SPECIAL_BYTE_END;
 98 |       break;
 99 |     case SLIP_ESCAPED_BYTE_ESC:
100 |       byte = SLIP_SPECIAL_BYTE_ESC;
101 |       break;
102 |     default:
103 |       error = SLIP_ERROR_UNKNOWN_ESCAPED_BYTE;
104 |       reset_rx(slip);
105 |       break;
106 |     }
107 | 
108 |     if (error != SLIP_NO_ERROR)
109 |       break;
110 | 
111 |     error = put_byte_to_buffer(slip, byte);
112 |     break;
113 |   }
114 | 
115 |   return error;
116 | }
117 | 


--------------------------------------------------------------------------------
/fx_cube.c:
--------------------------------------------------------------------------------
  1 | #include <SDL.h>
  2 | #include "SDL2_inprint.h"
  3 | 
  4 | #define target_width 320
  5 | #define target_height 240
  6 | static SDL_Texture *texture_cube;
  7 | static SDL_Texture *texture_text;
  8 | static SDL_Renderer *fx_renderer;
  9 | static SDL_Color line_color;
 10 | 
 11 | const char *text_m8c = "M8C";
 12 | const char *text_disconnected = "DEVICE DISCONNECTED";
 13 | 
 14 | static const float center_x = (float)target_width / 2;
 15 | static const float center_y = (float)target_height / 2;
 16 | 
 17 | static const float default_nodes[8][3] = {
 18 |     {-1, -1, -1}, {-1, -1, 1}, {-1, 1, -1}, {-1, 1, 1},
 19 |     {1, -1, -1},  {1, -1, 1},  {1, 1, -1},  {1, 1, 1}};
 20 | 
 21 | static int edges[12][2] = {{0, 1}, {1, 3}, {3, 2}, {2, 0}, {4, 5}, {5, 7},
 22 |                            {7, 6}, {6, 4}, {0, 4}, {1, 5}, {2, 6}, {3, 7}};
 23 | 
 24 | static float nodes[8][3];
 25 | 
 26 | static void scale(float factor0, float factor1, float factor2) {
 27 |   for (int i = 0; i < 8; i++) {
 28 |     nodes[i][0] *= factor0;
 29 |     nodes[i][1] *= factor1;
 30 |     nodes[i][2] *= factor2;
 31 |   }
 32 | }
 33 | 
 34 | static void rotate_cube(float angle_x, float angle_y) {
 35 |   float sin_x = SDL_sin(angle_x);
 36 |   float cos_x = SDL_cos(angle_x);
 37 |   float sin_y = SDL_sin(angle_y);
 38 |   float cos_y = SDL_cos(angle_y);
 39 |   for (int i = 0; i < 8; i++) {
 40 |     float x = nodes[i][0];
 41 |     float y = nodes[i][1];
 42 |     float z = nodes[i][2];
 43 | 
 44 |     nodes[i][0] = x * cos_x - z * sin_x;
 45 |     nodes[i][2] = z * cos_x + x * sin_x;
 46 | 
 47 |     z = nodes[i][2];
 48 | 
 49 |     nodes[i][1] = y * cos_y - z * sin_y;
 50 |     nodes[i][2] = z * cos_y + y * sin_y;
 51 |   }
 52 | }
 53 | 
 54 | void fx_cube_init(SDL_Renderer *target_renderer, SDL_Color foreground_color) {
 55 | 
 56 |   fx_renderer = target_renderer;
 57 |   line_color = foreground_color;
 58 | 
 59 |   texture_cube =
 60 |       SDL_CreateTexture(fx_renderer, SDL_PIXELFORMAT_ARGB8888,
 61 |                         SDL_TEXTUREACCESS_TARGET, target_width, target_height);
 62 |   texture_text =
 63 |       SDL_CreateTexture(fx_renderer, SDL_PIXELFORMAT_ARGB8888,
 64 |                         SDL_TEXTUREACCESS_TARGET, target_width, target_height);
 65 | 
 66 |   SDL_Texture *og_target = SDL_GetRenderTarget(fx_renderer);                        
 67 | 
 68 |   SDL_SetRenderTarget(fx_renderer, texture_text);
 69 | 
 70 |   inprint(fx_renderer, text_disconnected, 168, 230, 0xFFFFFF, 0x000000);
 71 |   inprint(fx_renderer, text_m8c, 2, 2, 0xFFFFFF, 0x000000);
 72 | 
 73 |   SDL_SetRenderTarget(fx_renderer, og_target);
 74 | 
 75 |   // Initialize default nodes
 76 |   SDL_memcpy(nodes, default_nodes, sizeof(default_nodes));
 77 | 
 78 |   scale(50, 50, 50);
 79 |   rotate_cube(M_PI / 4, SDL_atan(SDL_sqrt(2)));
 80 | 
 81 |   SDL_SetTextureBlendMode(texture_cube, SDL_BLENDMODE_BLEND);
 82 |   SDL_SetTextureBlendMode(texture_text, SDL_BLENDMODE_BLEND);
 83 | }
 84 | 
 85 | void fx_cube_destroy() {
 86 |   SDL_DestroyTexture(texture_cube);
 87 |   SDL_DestroyTexture(texture_text);
 88 | }
 89 | 
 90 | void fx_cube_update() {
 91 |   SDL_Point points[24];
 92 |   int points_counter = 0;
 93 |   SDL_Texture *og_texture = SDL_GetRenderTarget(fx_renderer);
 94 | 
 95 |   SDL_SetRenderTarget(fx_renderer, texture_cube);
 96 |   SDL_SetRenderDrawColor(fx_renderer, 0, 0, 0, 200);
 97 |   SDL_RenderClear(fx_renderer);
 98 | 
 99 |   int seconds = SDL_GetTicks() / 1000;
100 |   float scalefactor = 1 + (SDL_sin(seconds) * 0.01);
101 | 
102 |   scale(scalefactor, scalefactor, scalefactor);
103 |   rotate_cube(M_PI / 180, M_PI / 270);
104 | 
105 |   for (int i = 0; i < 12; i++) {
106 |     float *p1 = nodes[edges[i][0]];
107 |     float *p2 = nodes[edges[i][1]];
108 |     points[points_counter++] =
109 |         (SDL_Point){p1[0] + center_x, nodes[edges[i][0]][1] + center_y};
110 |     points[points_counter++] = (SDL_Point){p2[0] + center_x, p2[1] + center_y};
111 |   }
112 | 
113 |   SDL_RenderCopy(fx_renderer, texture_text, NULL, NULL);
114 |   SDL_SetRenderDrawColor(fx_renderer, line_color.r, line_color.g, line_color.b,
115 |                          line_color.a);
116 |   SDL_RenderDrawLines(fx_renderer, points, 24);
117 | 
118 |   SDL_SetRenderTarget(fx_renderer, og_texture);
119 |   SDL_RenderCopy(fx_renderer, texture_cube, NULL, NULL);
120 | }
121 | 


--------------------------------------------------------------------------------
/command.c:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 Jonne Kokkonen
  2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
  3 | 
  4 | #include <SDL_log.h>
  5 | 
  6 | #include "command.h"
  7 | #include "render.h"
  8 | 
  9 | // Convert 2 little-endian 8bit bytes to a 16bit integer
 10 | static uint16_t decodeInt16(uint8_t *data, uint8_t start) {
 11 |   return data[start] | (uint16_t)data[start + 1] << 8;
 12 | }
 13 | 
 14 | enum m8_command_bytes {
 15 |   draw_rectangle_command = 0xFE,
 16 |   draw_rectangle_command_datalength = 12,
 17 |   draw_character_command = 0xFD,
 18 |   draw_character_command_datalength = 12,
 19 |   draw_oscilloscope_waveform_command = 0xFC,
 20 |   draw_oscilloscope_waveform_command_mindatalength = 1 + 3,
 21 |   draw_oscilloscope_waveform_command_maxdatalength = 1 + 3 + 320,
 22 |   joypad_keypressedstate_command = 0xFB,
 23 |   joypad_keypressedstate_command_datalength = 2
 24 | };
 25 | 
 26 | static inline void dump_packet(uint32_t size, uint8_t *recv_buf) {
 27 |   for (uint16_t a = 0; a < size; a++) {
 28 |     SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "0x%02X ", recv_buf[a]);
 29 |   }
 30 |   SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "\n");
 31 | }
 32 | 
 33 | int process_command(uint8_t *data, uint32_t size) {
 34 | 
 35 |   uint8_t recv_buf[size + 1];
 36 | 
 37 |   memcpy(recv_buf, data, size);
 38 |   recv_buf[size] = 0;
 39 | 
 40 |   switch (recv_buf[0]) {
 41 | 
 42 |   case draw_rectangle_command:
 43 | 
 44 |     if (size != draw_rectangle_command_datalength) {
 45 |       SDL_LogError(
 46 |           SDL_LOG_CATEGORY_ERROR,
 47 |           "Invalid draw rectangle packet: expected length %d, got %d\n",
 48 |           draw_rectangle_command_datalength, size);
 49 |       dump_packet(size, recv_buf);
 50 |       return 0;
 51 |       break;
 52 |     } else {
 53 | 
 54 |       struct draw_rectangle_command rectcmd = {
 55 |           {decodeInt16(recv_buf, 1), decodeInt16(recv_buf, 3)}, // position x/y
 56 |           {decodeInt16(recv_buf, 5), decodeInt16(recv_buf, 7)}, // size w/h
 57 |           {recv_buf[9], recv_buf[10], recv_buf[11]}};           // color r/g/b
 58 | 
 59 |       draw_rectangle(&rectcmd);
 60 |       return 1;
 61 |     }
 62 | 
 63 |     break;
 64 | 
 65 |   case draw_character_command:
 66 | 
 67 |     if (size != draw_character_command_datalength) {
 68 |       SDL_LogError(
 69 |           SDL_LOG_CATEGORY_ERROR,
 70 |           "Invalid draw character packet: expected length %d, got %d\n",
 71 |           draw_character_command_datalength, size);
 72 |       dump_packet(size, recv_buf);
 73 |       return 0;
 74 |       break;
 75 |     } else {
 76 | 
 77 |       struct draw_character_command charcmd = {
 78 |           recv_buf[1],                                          // char
 79 |           {decodeInt16(recv_buf, 2), decodeInt16(recv_buf, 4)}, // position x/y
 80 |           {recv_buf[6], recv_buf[7], recv_buf[8]},    // foreground r/g/b
 81 |           {recv_buf[9], recv_buf[10], recv_buf[11]}}; // background r/g/b
 82 |       draw_character(&charcmd);
 83 |       return 1;
 84 |     }
 85 | 
 86 |     break;
 87 | 
 88 |   case draw_oscilloscope_waveform_command:
 89 | 
 90 |     if (size < draw_oscilloscope_waveform_command_mindatalength ||
 91 |         size > draw_oscilloscope_waveform_command_maxdatalength) {
 92 |       SDL_LogError(
 93 |           SDL_LOG_CATEGORY_ERROR,
 94 |           "Invalid draw oscilloscope packet: expected length between %d "
 95 |           "and %d, got "
 96 |           "%d\n",
 97 |           draw_oscilloscope_waveform_command_mindatalength,
 98 |           draw_oscilloscope_waveform_command_maxdatalength, size);
 99 |       dump_packet(size, recv_buf);
100 |       return 0;
101 |       break;
102 |     } else {
103 | 
104 |       struct draw_oscilloscope_waveform_command osccmd;
105 | 
106 |       osccmd.color =
107 |           (struct color){recv_buf[1], recv_buf[2], recv_buf[3]}; // color r/g/b
108 |       memcpy(osccmd.waveform, &recv_buf[4], size - 4);
109 | 
110 |       osccmd.waveform_size = size - 4;
111 | 
112 |       draw_waveform(&osccmd);
113 |       return 1;
114 |     }
115 | 
116 |     break;
117 | 
118 |   case joypad_keypressedstate_command:
119 |     /*
120 |     if (size != joypad_keypressedstate_command_datalength) {
121 |       SDL_LogError(SDL_LOG_CATEGORY_ERROR,
122 |               "Invalid joypad keypressed state packet: expected length %d, "
123 |               "got %d\n",
124 |               joypad_keypressedstate_command_datalength, size);
125 |       dump_packet(size, recv_buf);
126 |       break;
127 |     } */
128 | 
129 |     // nothing is done with joypad key pressed packets for now
130 |     return 1;
131 |     break;
132 | 
133 |   default:
134 | 
135 |     SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Invalid packet\n");
136 |     dump_packet(size, recv_buf);
137 |     return 0;
138 |     break;
139 |   }
140 | }
141 | 


--------------------------------------------------------------------------------
/inprint2.c:
--------------------------------------------------------------------------------
  1 | // Bitmap font routine originally by driedfruit, https://github.com/driedfruit/SDL_inprint
  2 | // Released into public domain.
  3 | // Modified to support adding a background to text.
  4 | 
  5 | #include <SDL2/SDL.h>
  6 | 
  7 | #include "inline_font.h" /* Actual font data */
  8 | 
  9 | #define CHARACTERS_PER_ROW 16   /* I like 16 x 8 fontsets. */
 10 | #define CHARACTERS_PER_COLUMN 8 /* 128 x 1 is another popular format. */
 11 | 
 12 | static SDL_Renderer *selected_renderer = NULL;
 13 | static SDL_Texture *inline_font = NULL;
 14 | static SDL_Texture *selected_font = NULL;
 15 | static Uint16 selected_font_w, selected_font_h;
 16 | 
 17 | void prepare_inline_font() {
 18 |   Uint32 *pix_ptr, tmp;
 19 |   int i, len, j;
 20 |   SDL_Surface *surface;
 21 |   Uint32 colors[2];
 22 | 
 23 |   selected_font_w = inline_font_width;
 24 |   selected_font_h = inline_font_height;
 25 | 
 26 |   if (inline_font != NULL) {
 27 |     selected_font = inline_font;
 28 |     return;
 29 |   }
 30 | 
 31 |   surface = SDL_CreateRGBSurface(0, inline_font_width, inline_font_height, 32,
 32 | #if SDL_BYTEORDER == SDL_BIG_ENDIAN
 33 |                                  0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
 34 | #else
 35 |                                  0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
 36 | #endif
 37 |   );
 38 |   colors[0] = SDL_MapRGBA(surface->format, 0xFF, 0xFF, 0xFF, 0xFF);
 39 |   colors[1] = SDL_MapRGBA(surface->format, 0x00, 0x00, 0x00,
 40 |                           0x00 /* or 0xFF, to have bg-color */);
 41 | 
 42 |   /* Get pointer to pixels and array length */
 43 |   pix_ptr = (Uint32 *)surface->pixels;
 44 |   len = surface->h * surface->w / 8;
 45 | 
 46 |   /* Copy */
 47 |   for (i = 0; i < len; i++) {
 48 |     tmp = (Uint8)inline_font_bits[i];
 49 |     for (j = 0; j < 8; j++) {
 50 |       Uint8 mask = (0x01 << j);
 51 |       pix_ptr[i * 8 + j] = colors[(tmp & mask) >> j];
 52 |     }
 53 |   }
 54 | 
 55 |   inline_font = SDL_CreateTextureFromSurface(selected_renderer, surface);
 56 |   SDL_FreeSurface(surface);
 57 | 
 58 |   selected_font = inline_font;
 59 | }
 60 | void kill_inline_font(void) {
 61 |   SDL_DestroyTexture(inline_font);
 62 |   inline_font = NULL;
 63 | }
 64 | void inrenderer(SDL_Renderer *renderer) { selected_renderer = renderer; }
 65 | void infont(SDL_Texture *font) {
 66 |   Uint32 format;
 67 |   int access;
 68 |   int w, h;
 69 | 
 70 |   if (font == NULL) {
 71 |     prepare_inline_font();
 72 |     return;
 73 |   }
 74 | 
 75 |   SDL_QueryTexture(font, &format, &access, &w, &h);
 76 | 
 77 |   selected_font = font;
 78 |   selected_font_w = w;
 79 |   selected_font_h = h;
 80 | }
 81 | void incolor1(SDL_Color *color) {
 82 |   SDL_SetTextureColorMod(selected_font, color->r, color->g, color->b);
 83 | }
 84 | void incolor(Uint32 fore,
 85 |              Uint32 unused) /* Color must be in 0x00RRGGBB format ! */
 86 | {
 87 |   SDL_Color pal[1];
 88 |   pal[0].r = (Uint8)((fore & 0x00FF0000) >> 16);
 89 |   pal[0].g = (Uint8)((fore & 0x0000FF00) >> 8);
 90 |   pal[0].b = (Uint8)((fore & 0x000000FF));
 91 |   SDL_SetTextureColorMod(selected_font, pal[0].r, pal[0].g, pal[0].b);
 92 | }
 93 | void inprint(SDL_Renderer *dst, const char *str, Uint32 x, Uint32 y,
 94 |              Uint32 fgcolor, Uint32 bgcolor) {
 95 |   SDL_Rect s_rect;
 96 |   SDL_Rect d_rect;
 97 |   SDL_Rect bg_rect;
 98 | 
 99 |   static uint32_t previous_fgcolor;
100 | 
101 |   d_rect.x = x;
102 |   d_rect.y = y;
103 |   s_rect.w = selected_font_w / CHARACTERS_PER_ROW;
104 |   s_rect.h = selected_font_h / CHARACTERS_PER_COLUMN;
105 |   d_rect.w = s_rect.w;
106 |   d_rect.h = s_rect.h;
107 | 
108 |   if (dst == NULL)
109 |     dst = selected_renderer;
110 | 
111 |   for (; *str; str++) {
112 |     int id = (int)*str;
113 | #if (CHARACTERS_PER_COLUMN != 1)
114 |     int row = id / CHARACTERS_PER_ROW;
115 |     int col = id % CHARACTERS_PER_ROW;
116 |     s_rect.x = col * s_rect.w;
117 |     s_rect.y = row * s_rect.h;
118 | #else
119 |     s_rect.x = id * s_rect.w;
120 |     s_rect.y = 0;
121 | #endif
122 |     if (id == '\n') {
123 |       d_rect.x = x;
124 |       d_rect.y += s_rect.h;
125 |       continue;
126 |     }
127 |     if (fgcolor != previous_fgcolor) {
128 |       incolor(fgcolor, 0);
129 |       previous_fgcolor = fgcolor;
130 |     }
131 |     if (bgcolor != -1) {
132 |       SDL_SetRenderDrawColor(selected_renderer,
133 |                              (Uint8)((bgcolor & 0x00FF0000) >> 16),
134 |                              (Uint8)((bgcolor & 0x0000FF00) >> 8),
135 |                              (Uint8)((bgcolor & 0x000000FF)), 0xFF);
136 |       bg_rect = d_rect;
137 |       bg_rect.w = 6;
138 |       SDL_RenderFillRect(dst, &bg_rect);
139 |     }
140 |     SDL_RenderCopy(dst, selected_font, &s_rect, &d_rect);
141 |     d_rect.x += s_rect.w;
142 |   }
143 | }
144 | SDL_Texture *get_inline_font(void) { return selected_font; }
145 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
  1 | name: m8c build
  2 | 
  3 | on:
  4 |   push:
  5 |   pull_request:
  6 |   workflow_dispatch:
  7 | 
  8 | jobs:
  9 |   build-win:
 10 |     runs-on: windows-latest
 11 |     strategy:
 12 |       fail-fast: false
 13 |       matrix:
 14 |         include:
 15 |           - { sys: mingw32, env: i686, win: win32 }
 16 |           - { sys: mingw64, env: x86_64, win: win64 }
 17 |     name: ${{ matrix.win }}
 18 |     defaults:
 19 |       run:
 20 |         shell: msys2 {0}
 21 |     env:
 22 |       MINGW_ARCH: ${{ matrix.sys }}
 23 |     steps:
 24 | 
 25 |     - name: 'git config'
 26 |       run: git config --global core.autocrlf input
 27 |       shell: bash
 28 | 
 29 |     - name: 'Checkout'
 30 |       uses: actions/checkout@v2
 31 |       with:
 32 |         fetch-depth: 0
 33 | 
 34 |     - name: 'Setup MSYS2'
 35 |       uses: msys2/setup-msys2@v2
 36 |       with:
 37 |         msystem: ${{ matrix.sys }}
 38 |         update: true
 39 |         install: mingw-w64-${{ matrix.env }}-toolchain make mingw-w64-${{ matrix.env }}-SDL2 mingw-w64-${{ matrix.env }}-libserialport zip dos2unix
 40 |   
 41 |     - name: 'Get current date'
 42 |       id: date
 43 |       run: echo "::set-output name=date::$(date +%Y%m%d)"
 44 | 
 45 |     - name: 'Build package'
 46 |       run: |
 47 |         make
 48 |         strip -g m8c.exe
 49 |         if [ ${{ matrix.win }} == "win32" ]
 50 |         then        
 51 |           cp /mingw32/bin/SDL2.dll .
 52 |           cp /mingw32/bin/libgcc_s_dw2-1.dll .
 53 |           cp /mingw32/bin/libserialport-0.dll .
 54 |           cp /mingw32/bin/libwinpthread-1.dll .
 55 |         else
 56 |           cp /mingw64/bin/SDL2.dll .
 57 |           cp /mingw64/bin/libserialport-0.dll .
 58 |         fi
 59 |         unix2dos README.md config.ini.sample LICENSE AUDIOGUIDE.md
 60 |     - name: 'Upload artifact (win32)'
 61 |       if: matrix.win == 'win32'
 62 |       uses: actions/upload-artifact@v2
 63 |       with:
 64 |         name: m8c-${{ steps.date.outputs.date }}-${{ matrix.win }}
 65 |         path: |
 66 |           m8c.exe
 67 |           SDL2.dll
 68 |           libserialport-0.dll
 69 |           libgcc_s_dw2-1.dll
 70 |           libwinpthread-1.dll
 71 |           gamecontrollerdb.txt
 72 |           LICENSE
 73 |           README.md
 74 |           AUDIOGUIDE.md
 75 |           config.ini.sample
 76 |     - name: 'Upload artifact (win64)'
 77 |       if: matrix.win == 'win64'
 78 |       uses: actions/upload-artifact@v2
 79 |       with:
 80 |         name: m8c-${{ steps.date.outputs.date }}-${{ matrix.win }}
 81 |         path: |
 82 |           m8c.exe
 83 |           SDL2.dll
 84 |           libserialport-0.dll
 85 |           gamecontrollerdb.txt
 86 |           LICENSE
 87 |           README.md
 88 |           AUDIOGUIDE.md
 89 |           config.ini.sample
 90 | 
 91 |   build-linux:
 92 |     runs-on: ubuntu-latest
 93 |     name: linux-x86_64
 94 |     steps:
 95 |       - name: 'Install dependencies'
 96 |         run: |
 97 |           sudo apt-get update
 98 |           sudo apt-get install --fix-missing build-essential libsdl2-dev libserialport-dev zip
 99 |       - name: 'Checkout'
100 |         uses: actions/checkout@v2
101 | 
102 |       - name: 'Get current date'
103 |         id: date
104 |         run: echo "::set-output name=date::$(date +%Y%m%d)"
105 | 
106 |       - name: 'Build package'
107 |         run: |
108 |           make
109 |       - name: 'Upload artifact'
110 |         uses: actions/upload-artifact@v2
111 |         with:
112 |           name: m8c-${{ steps.date.outputs.date }}-linux
113 |           path: |
114 |             LICENSE
115 |             README.md
116 |             AUDIOGUIDE.md
117 |             m8c
118 |             gamecontrollerdb.txt
119 |             config.ini.sample
120 |       
121 |   build-macos:
122 |     runs-on: macos-latest
123 |     
124 |     steps:
125 |       - name: 'Install dependencies'
126 |         run: brew install sdl2 libserialport pkg-config
127 | 
128 |       - name: 'Checkout'
129 |         uses: actions/checkout@v2
130 | 
131 |       - name: 'Get current date'
132 |         id: date
133 |         run: echo "::set-output name=date::$(date +%Y%m%d)"
134 | 
135 |       - name: 'Build package'
136 |         run: |
137 |           make
138 |           chmod 755 m8c
139 |           cd macos/m8c.app/Contents/
140 |           mkdir MacOS
141 |           cd MacOS
142 |           cp ../../../../m8c .
143 |           cp /usr/local/opt/sdl2/lib/libSDL2* .
144 |           cp /usr/local/opt/libserialport/lib/libserialport.* .
145 |           install_name_tool -change /usr/local/opt/libserialport/lib/libserialport.0.dylib @executable_path/libserialport.0.dylib m8c
146 |           install_name_tool -change /usr/local/opt/sdl2/lib/libSDL2-2.0.0.dylib @executable_path/libSDL2-2.0.0.dylib m8c
147 |           cd ../../../../
148 |           cp -r macos/m8c.app .
149 |           zip -r m8c.zip m8c.app LICENSE README.md AUDIOGUIDE.md config.ini.sample gamecontrollerdb.txt
150 |       - name: 'Upload artifact'
151 |         uses: actions/upload-artifact@v2
152 |         with:
153 |           name: m8c-${{ steps.date.outputs.date }}-macos
154 |           path: m8c.zip
155 |             
156 | 


--------------------------------------------------------------------------------
/serial.c:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 Jonne Kokkonen
  2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
  3 | 
  4 | // Contains portions of code from libserialport's examples released to the
  5 | // public domain
  6 | 
  7 | #include <SDL_log.h>
  8 | #include <libserialport.h>
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 12 | 
 13 | #include "serial.h"
 14 | 
 15 | // Helper function for error handling
 16 | static int check(enum sp_return result);
 17 | 
 18 | static int detect_m8_serial_device(struct sp_port *port) {
 19 |   // Check the connection method - we want USB serial devices
 20 |   enum sp_transport transport = sp_get_port_transport(port);
 21 | 
 22 |   if (transport == SP_TRANSPORT_USB) {
 23 |     // Get the USB vendor and product IDs.
 24 |     int usb_vid, usb_pid;
 25 |     sp_get_port_usb_vid_pid(port, &usb_vid, &usb_pid);
 26 | 
 27 |     if (usb_vid == 0x16C0 && usb_pid == 0x048A)
 28 |       return 1;
 29 |   }
 30 | 
 31 |   return 0;
 32 | }
 33 | 
 34 | // Checks for connected devices and whether the specified device still exists
 35 | int check_serial_port(struct sp_port *m8_port) {
 36 | 
 37 |   int device_found = 0;
 38 | 
 39 |   /* A pointer to a null-terminated array of pointers to
 40 |    * struct sp_port, which will contain the ports found.*/
 41 |   struct sp_port **port_list;
 42 | 
 43 |   /* Call sp_list_ports() to get the ports. The port_list
 44 |    * pointer will be updated to refer to the array created. */
 45 |   enum sp_return result = sp_list_ports(&port_list);
 46 | 
 47 |   if (result != SP_OK) {
 48 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "sp_list_ports() failed!\n");
 49 |     abort();
 50 |   }
 51 | 
 52 |   /* Iterate through the ports. When port_list[i] is NULL
 53 |    * this indicates the end of the list. */
 54 |   for (int i = 0; port_list[i] != NULL; i++) {
 55 |     struct sp_port *port = port_list[i];
 56 | 
 57 |     if (detect_m8_serial_device(port)) {
 58 |       if (strcmp(sp_get_port_name(port), sp_get_port_name(m8_port)) == 0)
 59 |         device_found = 1;
 60 |     }
 61 |   }
 62 | 
 63 |   sp_free_port_list(port_list);
 64 |   return device_found;
 65 | 
 66 | }
 67 | 
 68 | struct sp_port *init_serial(int verbose) {
 69 |   /* A pointer to a null-terminated array of pointers to
 70 |    * struct sp_port, which will contain the ports found.*/
 71 |   struct sp_port *m8_port = NULL;
 72 |   struct sp_port **port_list;
 73 | 
 74 |   if (verbose)
 75 |     SDL_Log("Looking for USB serial devices.\n");
 76 | 
 77 |   /* Call sp_list_ports() to get the ports. The port_list
 78 |    * pointer will be updated to refer to the array created. */
 79 |   enum sp_return result = sp_list_ports(&port_list);
 80 | 
 81 |   if (result != SP_OK) {
 82 |     SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "sp_list_ports() failed!\n");
 83 |     abort();
 84 |   }
 85 | 
 86 |   /* Iterate through the ports. When port_list[i] is NULL
 87 |    * this indicates the end of the list. */
 88 |   for (int i = 0; port_list[i] != NULL; i++) {
 89 |     struct sp_port *port = port_list[i];
 90 | 
 91 |     if (detect_m8_serial_device(port)) {
 92 |       SDL_Log("Found M8 in %s.\n", sp_get_port_name(port));
 93 |       sp_copy_port(port, &m8_port);
 94 |     }
 95 |   }
 96 | 
 97 |   sp_free_port_list(port_list);
 98 | 
 99 |   if (m8_port != NULL) {
100 |     // Open the serial port and configure it
101 |     SDL_Log("Opening port.\n");
102 |     enum sp_return result;
103 | 
104 |     result = sp_open(m8_port, SP_MODE_READ_WRITE);
105 |     if (check(result) != SP_OK)
106 |       return NULL;
107 | 
108 |     result = sp_set_baudrate(m8_port, 115200);
109 |     if (check(result) != SP_OK)
110 |       return NULL;
111 | 
112 |     result = sp_set_bits(m8_port, 8);
113 |     if (check(result) != SP_OK)
114 |       return NULL;
115 | 
116 |     result = sp_set_parity(m8_port, SP_PARITY_NONE);
117 |     if (check(result) != SP_OK)
118 |       return NULL;
119 | 
120 |     result = sp_set_stopbits(m8_port, 1);
121 |     if (check(result) != SP_OK)
122 |       return NULL;
123 | 
124 |     result = sp_set_flowcontrol(m8_port, SP_FLOWCONTROL_NONE);
125 |     if (check(result) != SP_OK)
126 |       return NULL;
127 |   } else {
128 |     if (verbose)
129 |       SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Cannot find a M8.\n");
130 |   }
131 | 
132 |   return (m8_port);
133 | }
134 | 
135 | // Helper function for error handling.
136 | static int check(enum sp_return result) {
137 | 
138 |   char *error_message;
139 | 
140 |   switch (result) {
141 |   case SP_ERR_ARG:
142 |     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Invalid argument.\n");
143 |     break;
144 |   case SP_ERR_FAIL:
145 |     error_message = sp_last_error_message();
146 |     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Failed: %s\n",
147 |                  error_message);
148 |     sp_free_error_message(error_message);
149 |     break;
150 |   case SP_ERR_SUPP:
151 |     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Not supported.\n");
152 |     break;
153 |   case SP_ERR_MEM:
154 |     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
155 |                  "Error: Couldn't allocate memory.\n");
156 |     break;
157 |   case SP_OK:
158 |   default:
159 |     break;
160 |   }
161 |   return result;
162 | }
163 | 


--------------------------------------------------------------------------------
/AUDIOGUIDE.md:
--------------------------------------------------------------------------------
  1 | # Audio setup for M8 headless 
  2 | 
  3 | ## Windows
  4 | 
  5 | * Right click Sound in Taskbar
  6 | * Open Sound Settings
  7 | * Select M8 (or whatever your Teensy Interface is named) as Input
  8 | * Select Device properties 
  9 | * Select Additional Device Properties 
 10 | * Select Listen tab 
 11 | * Check Listen to this device and then select output of your choice (whatever source plays your speakers/headphone uses)
 12 | 
 13 | ## Linux / Raspberry Pi
 14 | 
 15 | ### Pulseaudio
 16 | 
 17 | If you have a desktop installation, chances are you're using Pulseaudio which has a module for making an internal loopback.
 18 | 
 19 | run the following command in terminal:
 20 | 
 21 | ```
 22 | pacmd load-module module-loopback latency_msec=1
 23 | ```
 24 | 
 25 | after that, you should hear audio through your default input device. If not, check Input devices in Pulseaudio Volume Control
 26 | ```
 27 | pavucontrol
 28 | ```
 29 | 
 30 | If the tools are missing, install pavucontrol (Debian based systems):
 31 | ```
 32 | apt install pavucontrol
 33 | ```
 34 | 
 35 | ### JACK
 36 | 
 37 | It is possible to route the M8 USB audio to another audio interface in Linux without a DAW, using JACK Audio Connection kit and a few other command line tools.
 38 | 
 39 | Please note that this is not an optimal solution for getting audio from the headless M8, but as far as I know the easiest way to use the USB audio feature on Linux. The best parameters for running the applications can vary a lot depending on your configuration, and however you do it, there will be some latency.
 40 | 
 41 | It is possible to use the integrated audio of the Pi for this, but it has quite a poor quality and likely will have sound popping issues while running this.
 42 | 
 43 | These instructions were written for Raspberry PI OS desktop using a Raspberry Pi 3 B+, but should work for other Debian/Ubuntu flavors as well.
 44 | 
 45 | Open Terminal and run the commands below to setup the system.
 46 | 
 47 | -----
 48 | 
 49 | #### First time setup
 50 | 
 51 | #### Install JACK Audio Connection Kit 
 52 | 
 53 | The jackd2 package will provide the basic tools that make the audio patching possible. 
 54 | 
 55 | ```
 56 | sudo apt install jackd2
 57 | ```
 58 | 
 59 | #### Add your user to the audio group
 60 | 
 61 | This is required to get real time priority for the JACK process.
 62 | 
 63 | ```
 64 | sudo usermod -a -G audio $USER
 65 | ```
 66 | 
 67 | You need to log out completely or reboot for this change to take effect.
 68 | 
 69 | -----
 70 | 
 71 | #### Find your audio interface ALSA device id
 72 | 
 73 | Use the ```aplay -l``` command to list the audio devices present in the system.
 74 | 
 75 | ```
 76 | pi@raspberrypi:~ $ aplay -l
 77 | **** List of PLAYBACK Hardware Devices ****
 78 | card 0: Headphones [bcm2835 Headphones], device 0: bcm2835 Headphones [bcm2835 Headphones]
 79 |   Subdevices: 8/8
 80 |   Subdevice #0: subdevice #0
 81 |   Subdevice #1: subdevice #1
 82 |   Subdevice #2: subdevice #2
 83 |   Subdevice #3: subdevice #3
 84 |   Subdevice #4: subdevice #4
 85 |   Subdevice #5: subdevice #5
 86 |   Subdevice #6: subdevice #6
 87 |   Subdevice #7: subdevice #7
 88 | card 1: M8 [M8], device 0: USB Audio [USB Audio]
 89 |   Subdevices: 1/1
 90 |   Subdevice #0: subdevice #0
 91 | card 2: vc4hdmi [vc4-hdmi], device 0: MAI PCM vc4-hdmi-hifi-0 [MAI PCM vc4-hdmi-hifi-0]
 92 |   Subdevices: 1/1
 93 |   Subdevice #0: subdevice #0
 94 | card 3: v10 [AudioQuest DragonFly Red v1.0], device 0: USB Audio [USB Audio]
 95 |   Subdevices: 1/1
 96 |   Subdevice #0: subdevice #0
 97 | 
 98 | ```
 99 | 
100 | Take note of the card number you wish to use. In my case, I want to use card  3: v10.
101 | 
102 | After these steps have been taken care of, we can try to route some audio.
103 | 
104 | #### Start JACK server and route audio
105 | ```
106 | jackd -d alsa -d hw:M8 -r44100 -p512 &
107 | ```
108 | 
109 | This will start the JACK server using ALSA backend driver (-d alsa), open the M8 USB audio interface (-d hw:M8) with the sample rate of 44100hz (-r44100) and buffer period size of 512 frames (-p512). The program will run in background (the & character in the end specifies this).
110 | If you don't see your terminal prompt, just press enter and it should appear.
111 | 
112 | Next, we will create a virtual port for routing audio to another interface. We need to specify the audio interface id where we want to output audio here.
113 | 
114 | ```alsa_out -j m8out -d hw:<AUDIO INTERFACE NUMBER> -r 44100 &```
115 | 
116 | example:
117 | 
118 | ```alsa_out -j m8out -d hw:3 -r 44100 &```
119 | 
120 | This creates a JACK client called "m8out" (-j m8out) that performs output to ALSA audio hardware interface number 3 (-d hw:3) with a samplerate of 44100 (-r 44100). The ampersand at the end runs the program in the background.
121 | 
122 | If you wish to use the Pi integrated sound board, check the number of the "bcm2835 Headphones" device. Usually it is 0.
123 | 
124 | After the virtual port has been created, we need to connect it to the M8 USB Audio capture device.
125 | 
126 | ```
127 | jack_connect system:capture_1 m8out:playback_1
128 | jack_connect system:capture_2 m8out:playback_2
129 | ```
130 | 
131 | This will connect the audio ports. You should be able to hear sounds from the M8 now.
132 | 
133 | If you wish to shut down the applications, you can do that by sending a interrupt signal to the processes.
134 | 
135 | ```killall -s SIGINT jackd alsa_out```
136 | 
137 | 
138 | #### TL;DR
139 | Run these in Terminal:
140 | 
141 | ```
142 | sudo apt install jackd2
143 | sudo usermod -a -G audio $USER
144 | sudo reboot
145 | 
146 | ```
147 | ```
148 | jackd -d alsa -d hw:M8 -r44100 -p512 &
149 | alsa_out -j m8out -d hw:0 -r 44100 &
150 | jack_connect system:capture_1 m8out:playback_1
151 | jack_connect system:capture_2 m8out:playback_2
152 | ```
153 | 


--------------------------------------------------------------------------------
/inline_font.h.comicsans:
--------------------------------------------------------------------------------
 1 | #define inline_font_width 128
 2 | #define inline_font_height 64
 3 | static unsigned char inline_font_bits[] = {
 4 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
 5 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
 6 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
 7 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
 8 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
 9 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
10 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
11 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
12 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
13 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
14 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
15 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
16 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
17 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
18 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
19 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
20 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
21 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
22 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
23 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
24 | 0xff, 0xff, 0xff, 0xff, 0xf3, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
25 | 0xfd, 0xf9, 0xff, 0xf1, 0xf9, 0xf9, 0xfb, 0xfd, 0xfb, 0xff, 0xfd, 0xff, 0xff, 
26 | 0xff, 0xf7, 0xff, 0xfd, 0xf9, 0xf5, 0xfa, 0xe9, 0xf9, 0xfb, 0xfd, 0xf7, 0xf9, 
27 | 0xf8, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xfd, 0xf9, 0xf0, 0xf9, 0xf1, 0xf9, 0xfb, 
28 | 0xfd, 0xf7, 0xf0, 0xfd, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0xf5, 0xe3, 
29 | 0xfb, 0xf2, 0xff, 0xfd, 0xf7, 0xf9, 0xff, 0xff, 0xfc, 0xff, 0xfd, 0xff, 0xff, 
30 | 0xff, 0xf0, 0xeb, 0xe3, 0xf6, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 
31 | 0xfd, 0xff, 0xfd, 0xff, 0xfa, 0xf1, 0xe5, 0xf1, 0xff, 0xfb, 0xfb, 0xff, 0xff, 
32 | 0xfb, 0xff, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xf3, 
33 | 0xf9, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 
34 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xf9, 0xfb, 0xf3, 
35 | 0xf1, 0xf9, 0xf0, 0xfb, 0xf0, 0xf9, 0xf9, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf8, 
36 | 0xf6, 0xf9, 0xf5, 0xf7, 0xfa, 0xfe, 0xfc, 0xf7, 0xf6, 0xf6, 0xff, 0xff, 0xfb, 
37 | 0xff, 0xfd, 0xfb, 0xf2, 0xfb, 0xf7, 0xf9, 0xf0, 0xf0, 0xf8, 0xfb, 0xf9, 0xf6, 
38 | 0xff, 0xff, 0xfc, 0xf8, 0xfb, 0xf9, 0xf4, 0xfb, 0xfb, 0xf7, 0xfb, 0xf7, 0xf6, 
39 | 0xfd, 0xf6, 0xf1, 0xfd, 0xfb, 0xfd, 0xf8, 0xf7, 0xfd, 0xf6, 0xfb, 0xfd, 0xf6, 
40 | 0xfb, 0xf7, 0xf6, 0xfd, 0xf6, 0xf7, 0xff, 0xff, 0xfb, 0xff, 0xfb, 0xff, 0xf9, 
41 | 0xf1, 0xe1, 0xf9, 0xff, 0xf8, 0xf9, 0xff, 0xf9, 0xf9, 0xfd, 0xfb, 0xf7, 0xff, 
42 | 0xfc, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
43 | 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xf3, 0xff, 0xff, 0xf0, 0xff, 
44 | 0xff, 0xff, 0xff, 0xfd, 0xff, 0xf5, 0xf6, 0xff, 0xf9, 0xf9, 0xff, 0xf5, 0xfc, 
45 | 0xf0, 0xfe, 0xf3, 0xf6, 0xf8, 0xf0, 0xf6, 0xfe, 0xf5, 0xf4, 0xf9, 0xf6, 0xf5, 
46 | 0xf8, 0xfe, 0xfa, 0xfe, 0xfe, 0xfd, 0xf6, 0xfd, 0xfb, 0xfa, 0xfe, 0xf4, 0xf4, 
47 | 0xf6, 0xf0, 0xf1, 0xf6, 0xfe, 0xf6, 0xfe, 0xf0, 0xfe, 0xf6, 0xfd, 0xfb, 0xfc, 
48 | 0xfe, 0xf0, 0xf4, 0xf6, 0xf0, 0xf6, 0xf8, 0xfe, 0xf6, 0xf0, 0xfe, 0xf0, 0xf0, 
49 | 0xfd, 0xfb, 0xfc, 0xfe, 0xf2, 0xf2, 0xf6, 0xf4, 0xfe, 0xf6, 0xf1, 0xf6, 0xfe, 
50 | 0xfe, 0xf6, 0xf6, 0xfd, 0xfa, 0xfa, 0xfe, 0xfa, 0xf6, 0xf6, 0xf6, 0xff, 0xf8, 
51 | 0xff, 0xf8, 0xf0, 0xff, 0xf9, 0xf6, 0xf8, 0xf9, 0xf6, 0xf0, 0xff, 0xff, 0xf9, 
52 | 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
53 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 
54 | 0xff, 0xf1, 0xff, 0xf1, 0xf9, 0xff, 0xf8, 0xf9, 0xf8, 0xf1, 0xfb, 0xf6, 0xfe, 
55 | 0xeb, 0xf5, 0xf6, 0xf0, 0xfd, 0xfe, 0xf7, 0xf6, 0xff, 0xf6, 0xf6, 0xf6, 0xfe, 
56 | 0xfb, 0xf6, 0xf6, 0xea, 0xf9, 0xf6, 0xfb, 0xfd, 0xfd, 0xf7, 0xff, 0xff, 0xfa, 
57 | 0xf6, 0xf6, 0xf9, 0xfb, 0xf6, 0xf6, 0xea, 0xfb, 0xf9, 0xfb, 0xfd, 0xfd, 0xf7, 
58 | 0xff, 0xff, 0xf8, 0xf6, 0xf8, 0xf7, 0xfb, 0xf6, 0xf9, 0xe4, 0xf9, 0xfb, 0xfd, 
59 | 0xfd, 0xfb, 0xf7, 0xff, 0xff, 0xfe, 0xf4, 0xfa, 0xf7, 0xfb, 0xf6, 0xf9, 0xe4, 
60 | 0xf6, 0xfd, 0xfe, 0xfd, 0xfb, 0xf7, 0xff, 0xff, 0xfe, 0xf9, 0xf6, 0xf8, 0xff, 
61 | 0xf9, 0xfb, 0xf5, 0xff, 0xfd, 0xf0, 0xfd, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xf7, 
62 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xf1, 0xff, 
63 | 0xf0, 0xf9, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
64 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0xf3, 0xff, 0xfe, 
65 | 0xfb, 0xf9, 0xfe, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xf7, 0xff, 
66 | 0xfd, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf6, 
67 | 0xf9, 0xf1, 0xf9, 0xf0, 0xf1, 0xf0, 0xf9, 0xf8, 0xfa, 0xfb, 0xe0, 0xf0, 0xf9, 
68 | 0xff, 0xf6, 0xf6, 0xfe, 0xf6, 0xfa, 0xfd, 0xf6, 0xf6, 0xfb, 0xfb, 0xfc, 0xfb, 
69 | 0xea, 0xf6, 0xf6, 0xff, 0xf6, 0xf8, 0xfe, 0xf6, 0xfc, 0xfd, 0xf6, 0xf6, 0xfb, 
70 | 0xfb, 0xfa, 0xfb, 0xea, 0xf6, 0xf6, 0xff, 0xf1, 0xff, 0xf9, 0xf1, 0xf0, 0xf8, 
71 | 0xf0, 0xf6, 0xf1, 0xfb, 0xf6, 0xf1, 0xea, 0xf6, 0xf9, 0xff, 0xff, 0xff, 0xff, 
72 | 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
73 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xfc, 0xfb, 0xfb, 0xfe, 
74 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
75 | 0xfd, 0xfb, 0xfd, 0xff, 0xf0, 0xf8, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xf6, 0xf2, 
76 | 0xff, 0xff, 0xf1, 0xfd, 0xfb, 0xfd, 0xff, 0xf6, 0xf6, 0xf1, 0xf8, 0xf8, 0xf0, 
77 | 0xf6, 0xf5, 0xf2, 0xf6, 0xf6, 0xfb, 0xfd, 0xfb, 0xfe, 0xf5, 0xf6, 0xf6, 0xf6, 
78 | 0xfe, 0xfe, 0xfd, 0xf6, 0xf9, 0xf0, 0xf9, 0xf6, 0xfd, 0xfe, 0xfb, 0xf9, 0xf2, 
79 | 0xf6, 0xf8, 0xf6, 0xfe, 0xf9, 0xfd, 0xf6, 0xfb, 0xf5, 0xf9, 0xf9, 0xf0, 0xfd, 
80 | 0xfb, 0xfd, 0xff, 0xf6, 0xfe, 0xf1, 0xfe, 0xf8, 0xf1, 0xf0, 0xff, 0xff, 0xf6, 
81 | 0xfb, 0xff, 0xfd, 0xfb, 0xfd, 0xff, 0xf6, 0xfe, 0xf7, 0xff, 0xff, 0xff, 0xff, 
82 | 0xff, 0xff, 0xff, 0xfd, 0xff, 0xfb, 0xfb, 0xfe, 0xff, 0xf6  };
83 | 


--------------------------------------------------------------------------------
/ini.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright (c) 2016 rxi
  3 |  *
  4 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  5 |  * of this software and associated documentation files (the "Software"), to deal
  6 |  * in the Software without restriction, including without limitation the rights
  7 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  8 |  * copies of the Software, and to permit persons to whom the Software is
  9 |  * furnished to do so, subject to the following conditions:
 10 |  *
 11 |  * The above copyright notice and this permission notice shall be included in
 12 |  * all copies or substantial portions of the Software.
 13 |  *
 14 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 15 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 16 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 17 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 18 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 19 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 20 |  * SOFTWARE.
 21 |  */
 22 | 
 23 | #include <stdio.h>
 24 | #include <stdlib.h>
 25 | #include <string.h>
 26 | #include <ctype.h>
 27 | 
 28 | #include "ini.h"
 29 | 
 30 | struct ini_t {
 31 |   char *data;
 32 |   char *end;
 33 | };
 34 | 
 35 | 
 36 | /* Case insensitive string compare */
 37 | static int strcmpci(const char *a, const char *b) {
 38 |   for (;;) {
 39 |     int d = tolower(*a) - tolower(*b);
 40 |     if (d != 0 || !*a) {
 41 |       return d;
 42 |     }
 43 |     a++, b++;
 44 |   }
 45 | }
 46 | 
 47 | /* Returns the next string in the split data */
 48 | static char* next(ini_t *ini, char *p) {
 49 |   p += strlen(p);
 50 |   while (p < ini->end && *p == '\0') {
 51 |     p++;
 52 |   }
 53 |   return p;
 54 | }
 55 | 
 56 | static void trim_back(ini_t *ini, char *p) {
 57 |   while (p >= ini->data && (*p == ' ' || *p == '\t' || *p == '\r')) {
 58 |     *p-- = '\0';
 59 |   }
 60 | }
 61 | 
 62 | static char* discard_line(ini_t *ini, char *p) {
 63 |   while (p < ini->end && *p != '\n') {
 64 |     *p++ = '\0';
 65 |   }
 66 |   return p;
 67 | }
 68 | 
 69 | 
 70 | static char *unescape_quoted_value(ini_t *ini, char *p) {
 71 |   /* Use `q` as write-head and `p` as read-head, `p` is always ahead of `q`
 72 |    * as escape sequences are always larger than their resultant data */
 73 |   char *q = p;
 74 |   p++;
 75 |   while (p < ini->end && *p != '"' && *p != '\r' && *p != '\n') {
 76 |     if (*p == '\\') {
 77 |       /* Handle escaped char */
 78 |       p++;
 79 |       switch (*p) {
 80 |         default   : *q = *p;    break;
 81 |         case 'r'  : *q = '\r';  break;
 82 |         case 'n'  : *q = '\n';  break;
 83 |         case 't'  : *q = '\t';  break;
 84 |         case '\r' :
 85 |         case '\n' :
 86 |         case '\0' : goto end;
 87 |       }
 88 | 
 89 |     } else {
 90 |       /* Handle normal char */
 91 |       *q = *p;
 92 |     }
 93 |     q++, p++;
 94 |   }
 95 | end:
 96 |   return q;
 97 | }
 98 | 
 99 | 
100 | /* Splits data in place into strings containing section-headers, keys and
101 |  * values using one or more '\0' as a delimiter. Unescapes quoted values */
102 | static void split_data(ini_t *ini) {
103 |   char *value_start, *line_start;
104 |   char *p = ini->data;
105 | 
106 |   while (p < ini->end) {
107 |     switch (*p) {
108 |       case '\r':
109 |       case '\n':
110 |       case '\t':
111 |       case ' ':
112 |         *p = '\0';
113 |         /* Fall through */
114 | 
115 |       case '\0':
116 |         p++;
117 |         break;
118 | 
119 |       case '[':
120 |         p += strcspn(p, "]\n");
121 |         *p = '\0';
122 |         break;
123 | 
124 |       case ';':
125 |         p = discard_line(ini, p);
126 |         break;
127 | 
128 |       default:
129 |         line_start = p;
130 |         p += strcspn(p, "=\n");
131 | 
132 |         /* Is line missing a '='? */
133 |         if (*p != '=') {
134 |           p = discard_line(ini, line_start);
135 |           break;
136 |         }
137 |         trim_back(ini, p - 1);
138 | 
139 |         /* Replace '=' and whitespace after it with '\0' */
140 |         do {
141 |           *p++ = '\0';
142 |         } while (*p == ' ' || *p == '\r' || *p == '\t');
143 | 
144 |         /* Is a value after '=' missing? */
145 |         if (*p == '\n' || *p == '\0') {
146 |           p = discard_line(ini, line_start);
147 |           break;
148 |         }
149 | 
150 |         if (*p == '"') {
151 |           /* Handle quoted string value */
152 |           value_start = p;
153 |           p = unescape_quoted_value(ini, p);
154 | 
155 |           /* Was the string empty? */
156 |           if (p == value_start) {
157 |             p = discard_line(ini, line_start);
158 |             break;
159 |           }
160 | 
161 |           /* Discard the rest of the line after the string value */
162 |           p = discard_line(ini, p);
163 | 
164 |         } else {
165 |           /* Handle normal value */
166 |           p += strcspn(p, "\n");
167 |           trim_back(ini, p - 1);
168 |         }
169 |         break;
170 |     }
171 |   }
172 | }
173 | 
174 | 
175 | 
176 | ini_t* ini_load(const char *filename) {
177 |   ini_t *ini = NULL;
178 |   FILE *fp = NULL;
179 |   int n, sz;
180 | 
181 |   /* Init ini struct */
182 |   ini = malloc(sizeof(*ini));
183 |   if (!ini) {
184 |     goto fail;
185 |   }
186 |   memset(ini, 0, sizeof(*ini));
187 | 
188 |   /* Open file */
189 |   fp = fopen(filename, "rb");
190 |   if (!fp) {
191 |     goto fail;
192 |   }
193 | 
194 |   /* Get file size */
195 |   fseek(fp, 0, SEEK_END);
196 |   sz = ftell(fp);
197 |   if (sz==0) {
198 |     goto fail;
199 |   }
200 |   rewind(fp);
201 | 
202 |   /* Load file content into memory, null terminate, init end var */
203 |   ini->data = malloc(sz + 1);
204 |   ini->data[sz] = '\0';
205 |   ini->end = ini->data  + sz;
206 |   n = fread(ini->data, 1, sz, fp);
207 |   if (n != sz) {
208 |     goto fail;
209 |   }
210 | 
211 |   /* Prepare data */
212 |   split_data(ini);
213 | 
214 |   /* Clean up and return */
215 |   fclose(fp);
216 |   return ini;
217 | 
218 | fail:
219 |   if (fp) fclose(fp);
220 |   if (ini) ini_free(ini);
221 |   return NULL;
222 | }
223 | 
224 | 
225 | void ini_free(ini_t *ini) {
226 |   free(ini->data);
227 |   free(ini);
228 | }
229 | 
230 | 
231 | const char* ini_get(ini_t *ini, const char *section, const char *key) {
232 |   char *current_section = "";
233 |   char *val;
234 |   char *p = ini->data;
235 | 
236 |   if (*p == '\0') {
237 |     p = next(ini, p);
238 |   }
239 | 
240 |   while (p < ini->end) {
241 |     if (*p == '[') {
242 |       /* Handle section */
243 |       current_section = p + 1;
244 | 
245 |     } else {
246 |       /* Handle key */
247 |       val = next(ini, p);
248 |       if (!section || !strcmpci(section, current_section)) {
249 |         if (!strcmpci(p, key)) {
250 |           return val;
251 |         }
252 |       }
253 |       p = val;
254 |     }
255 | 
256 |     p = next(ini, p);
257 |   }
258 | 
259 |   return NULL;
260 | }
261 | 
262 | 
263 | int ini_sget(
264 |   ini_t *ini, const char *section, const char *key,
265 |   const char *scanfmt, void *dst
266 | ) {
267 |   const char *val = ini_get(ini, section, key);
268 |   if (!val) {
269 |     return 0;
270 |   }
271 |   if (scanfmt) {
272 |     sscanf(val, scanfmt, dst);
273 |   } else {
274 |     *((const char**) dst) = val;
275 |   }
276 |   return 1;
277 | }
278 | 


--------------------------------------------------------------------------------
/inline_font.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | The FontStruction “M8stealth57”
  3 | (https://fontstruct.com/fontstructions/show/2043303) by “trash80” is licensed
  4 | under a Creative Commons Attribution Share Alike license
  5 | (http://creativecommons.org/licenses/by-sa/3.0/). “M8stealth57” was originally
  6 | cloned (copied) from the FontStruction “stealth57”
  7 | (https://fontstruct.com/fontstructions/show/413734) by “trash80”, which is
  8 | licensed under a Creative Commons Attribution Share Alike license
  9 | (http://creativecommons.org/licenses/by-sa/3.0/).
 10 | 
 11 | Used with permission from the author.
 12 | */
 13 | 
 14 | #define inline_font_width 128
 15 | #define inline_font_height 64
 16 | static unsigned char inline_font_bits[] = {
 17 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 18 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 19 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 20 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 21 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 22 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 23 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 24 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 25 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 26 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 27 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 28 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 29 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 30 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 31 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 32 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 33 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 34 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 35 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 36 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 37 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 38 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xf5, 0xff, 0xfb, 0xff, 0xf9, 0xfb,
 39 |     0xef, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xfe, 0xf5, 0xf5,
 40 |     0xe0, 0xec, 0xf6, 0xfb, 0xf7, 0xfd, 0xf5, 0xfb, 0xff, 0xff, 0xff, 0xef,
 41 |     0xff, 0xfe, 0xff, 0xe0, 0xfa, 0xf4, 0xfa, 0xff, 0xf7, 0xfd, 0xfb, 0xfb,
 42 |     0xff, 0xff, 0xff, 0xf7, 0xff, 0xfe, 0xff, 0xf5, 0xe0, 0xfb, 0xed, 0xff,
 43 |     0xf7, 0xfd, 0xf5, 0xe0, 0xff, 0xe0, 0xff, 0xfb, 0xff, 0xfe, 0xff, 0xe0,
 44 |     0xeb, 0xe5, 0xea, 0xff, 0xf7, 0xfd, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfd,
 45 |     0xff, 0xff, 0xff, 0xf5, 0xe0, 0xe6, 0xf6, 0xff, 0xf7, 0xfd, 0xff, 0xfb,
 46 |     0xfb, 0xff, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xe9, 0xff,
 47 |     0xef, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff,
 48 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 49 |     0xe0, 0xfb, 0xe0, 0xe0, 0xee, 0xe0, 0xe0, 0xe0, 0xe1, 0xe0, 0xff, 0xff,
 50 |     0xff, 0xff, 0xff, 0xf1, 0xee, 0xf8, 0xef, 0xef, 0xee, 0xfe, 0xfe, 0xef,
 51 |     0xee, 0xee, 0xff, 0xff, 0xf7, 0xff, 0xfd, 0xee, 0xe6, 0xfb, 0xef, 0xef,
 52 |     0xee, 0xfe, 0xfe, 0xef, 0xee, 0xee, 0xfd, 0xfd, 0xf3, 0xe0, 0xf9, 0xef,
 53 |     0xea, 0xfb, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xf7, 0xe0, 0xe0, 0xff, 0xff,
 54 |     0xf1, 0xff, 0xf1, 0xf7, 0xec, 0xfb, 0xfe, 0xef, 0xef, 0xef, 0xee, 0xfb,
 55 |     0xee, 0xef, 0xff, 0xff, 0xf3, 0xe0, 0xf9, 0xfb, 0xee, 0xfb, 0xfe, 0xef,
 56 |     0xef, 0xef, 0xee, 0xfb, 0xee, 0xef, 0xfd, 0xfd, 0xf7, 0xff, 0xfd, 0xff,
 57 |     0xe0, 0xe0, 0xe0, 0xe0, 0xef, 0xe0, 0xe0, 0xfb, 0xf0, 0xef, 0xff, 0xfd,
 58 |     0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 59 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf1, 0xf0, 0xf1,
 60 |     0xf0, 0xe0, 0xe0, 0xf1, 0xee, 0xe0, 0xef, 0xee, 0xfe, 0xee, 0xee, 0xf1,
 61 |     0xee, 0xee, 0xee, 0xee, 0xee, 0xfe, 0xfe, 0xee, 0xee, 0xfb, 0xef, 0xf6,
 62 |     0xfe, 0xe4, 0xec, 0xee, 0xe2, 0xee, 0xee, 0xfe, 0xee, 0xfe, 0xfe, 0xfe,
 63 |     0xee, 0xfb, 0xef, 0xfa, 0xfe, 0xea, 0xea, 0xee, 0xea, 0xe0, 0xf0, 0xfe,
 64 |     0xee, 0xf0, 0xf0, 0xfe, 0xe0, 0xfb, 0xef, 0xfc, 0xfe, 0xee, 0xe6, 0xee,
 65 |     0xe2, 0xee, 0xee, 0xfe, 0xee, 0xfe, 0xfe, 0xe6, 0xee, 0xfb, 0xee, 0xfa,
 66 |     0xfe, 0xee, 0xee, 0xee, 0xfe, 0xee, 0xee, 0xee, 0xee, 0xfe, 0xfe, 0xee,
 67 |     0xee, 0xfb, 0xee, 0xf6, 0xfe, 0xee, 0xee, 0xee, 0xf1, 0xee, 0xf0, 0xf1,
 68 |     0xf0, 0xe0, 0xfe, 0xf1, 0xee, 0xe0, 0xf1, 0xee, 0xe0, 0xee, 0xee, 0xf1,
 69 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 70 |     0xff, 0xff, 0xff, 0xff, 0xf0, 0xf1, 0xf0, 0xe1, 0xe0, 0xee, 0xee, 0xee,
 71 |     0xee, 0xee, 0xe0, 0xe7, 0xfe, 0xfc, 0xfb, 0xff, 0xee, 0xee, 0xee, 0xfe,
 72 |     0xfb, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef, 0xf7, 0xfe, 0xfd, 0xf5, 0xff,
 73 |     0xee, 0xee, 0xee, 0xfe, 0xfb, 0xee, 0xee, 0xee, 0xf5, 0xee, 0xf7, 0xf7,
 74 |     0xfd, 0xfd, 0xff, 0xff, 0xf0, 0xee, 0xf0, 0xf1, 0xfb, 0xee, 0xee, 0xee,
 75 |     0xfb, 0xe1, 0xfb, 0xf7, 0xfb, 0xfd, 0xff, 0xff, 0xfe, 0xea, 0xf6, 0xef,
 76 |     0xfb, 0xee, 0xf5, 0xea, 0xf5, 0xef, 0xfd, 0xf7, 0xf7, 0xfd, 0xff, 0xff,
 77 |     0xfe, 0xf6, 0xee, 0xef, 0xfb, 0xee, 0xf5, 0xe4, 0xee, 0xef, 0xfe, 0xf7,
 78 |     0xef, 0xfd, 0xff, 0xff, 0xfe, 0xe9, 0xee, 0xf0, 0xfb, 0xf1, 0xfb, 0xee,
 79 |     0xee, 0xf0, 0xe0, 0xe7, 0xef, 0xfc, 0xff, 0xe0, 0xff, 0xff, 0xff, 0xff,
 80 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 81 |     0xfd, 0xff, 0xfe, 0xff, 0xef, 0xff, 0xe3, 0xff, 0xfe, 0xfb, 0xf7, 0xfe,
 82 |     0xf9, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xfe, 0xff, 0xef, 0xff, 0xfb, 0xff,
 83 |     0xfe, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xe0, 0xe0,
 84 |     0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xf9, 0xf7, 0xee, 0xfb, 0xe0, 0xe0, 0xe0,
 85 |     0xff, 0xef, 0xee, 0xfe, 0xee, 0xee, 0xfb, 0xee, 0xee, 0xfb, 0xf7, 0xf6,
 86 |     0xfb, 0xea, 0xee, 0xee, 0xff, 0xe0, 0xee, 0xfe, 0xee, 0xe0, 0xfb, 0xe0,
 87 |     0xee, 0xfb, 0xf7, 0xfa, 0xfb, 0xea, 0xee, 0xee, 0xff, 0xee, 0xee, 0xfe,
 88 |     0xee, 0xfe, 0xfb, 0xef, 0xee, 0xfb, 0xf7, 0xf4, 0xfb, 0xea, 0xee, 0xee,
 89 |     0xff, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xfb, 0xe0, 0xee, 0xf1, 0xf8, 0xee,
 90 |     0xf1, 0xea, 0xee, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 91 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 92 |     0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xfb, 0xe0, 0xff, 0xc0,
 93 |     0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee,
 94 |     0xfb, 0xee, 0xed, 0xd6, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xee, 0xee, 0xea,
 95 |     0xee, 0xee, 0xe0, 0xee, 0xfb, 0xee, 0xf2, 0xd4, 0xee, 0xee, 0xfe, 0xfe,
 96 |     0xfb, 0xee, 0xee, 0xea, 0xf5, 0xee, 0xf7, 0xee, 0xfb, 0xea, 0xff, 0xda,
 97 |     0xee, 0xee, 0xfe, 0xe0, 0xfb, 0xee, 0xf6, 0xea, 0xfb, 0xe0, 0xfb, 0xee,
 98 |     0xfb, 0xee, 0xff, 0xd4, 0xe0, 0xe0, 0xfe, 0xef, 0xfb, 0xee, 0xfa, 0xea,
 99 |     0xf5, 0xef, 0xfd, 0xee, 0xfb, 0xee, 0xff, 0xd6, 0xfe, 0xef, 0xfe, 0xe0,
100 |     0xe3, 0xe0, 0xfc, 0xe0, 0xee, 0xe0, 0xe0, 0xe0, 0xfb, 0xe0, 0xff, 0xc0,
101 |     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
102 |     0xff, 0xff, 0xff, 0xff};
103 | 


--------------------------------------------------------------------------------
/render.c:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 Jonne Kokkonen
  2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
  3 | 
  4 | #include "render.h"
  5 | 
  6 | #include <SDL.h>
  7 | #include <stdio.h>
  8 | 
  9 | #include "SDL2_inprint.h"
 10 | #include "SDL_log.h"
 11 | #include "SDL_render.h"
 12 | #include "command.h"
 13 | #include "fx_cube.h"
 14 | 
 15 | SDL_Window *win;
 16 | SDL_Renderer *rend;
 17 | SDL_Texture *maintexture;
 18 | SDL_Color background_color = (SDL_Color){0, 0, 0, 0};
 19 | 
 20 | static uint32_t ticks_fps;
 21 | static int fps;
 22 | uint8_t fullscreen = 0;
 23 | 
 24 | static uint8_t dirty = 0;
 25 | 
 26 | // Initializes SDL and creates a renderer and required surfaces
 27 | int initialize_sdl(int init_fullscreen, int init_use_gpu) {
 28 |   //ticks = SDL_GetTicks();
 29 | 
 30 |   const int window_width = 640;  // SDL window width
 31 |   const int window_height = 480; // SDL window height
 32 | 
 33 |   if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
 34 |     SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "SDL_Init: %s\n", SDL_GetError());
 35 |     return -1;
 36 |   }
 37 |   // SDL documentation recommends this
 38 |   atexit(SDL_Quit);
 39 | 
 40 |   win = SDL_CreateWindow("m8c", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 41 |                          window_width, window_height,
 42 |                          SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL |
 43 |                              SDL_WINDOW_RESIZABLE | init_fullscreen);
 44 | 
 45 |   rend = SDL_CreateRenderer(
 46 |       win, -1, init_use_gpu ? SDL_RENDERER_ACCELERATED : SDL_RENDERER_SOFTWARE);
 47 | 
 48 |   SDL_RenderSetLogicalSize(rend, 320, 240);
 49 | 
 50 |   maintexture = SDL_CreateTexture(rend, SDL_PIXELFORMAT_ARGB8888,
 51 |                                   SDL_TEXTUREACCESS_TARGET, 320, 240);
 52 | 
 53 |   SDL_SetRenderTarget(rend, maintexture);
 54 | 
 55 |   SDL_SetRenderDrawColor(rend, 0x00, 0x00, 0x00, 0x00);
 56 |   SDL_RenderClear(rend);
 57 | 
 58 |   // Initialize a texture for the font and read the inline font bitmap
 59 |   inrenderer(rend);
 60 |   prepare_inline_font();
 61 | 
 62 |   SDL_LogSetAllPriority(SDL_LOG_PRIORITY_INFO);
 63 | 
 64 |   dirty = 1;
 65 | 
 66 |   return 1;
 67 | }
 68 | 
 69 | void close_renderer() {
 70 |   SDL_DestroyTexture(maintexture);
 71 |   SDL_DestroyRenderer(rend);
 72 |   SDL_DestroyWindow(win);
 73 | }
 74 | 
 75 | void toggle_fullscreen() {
 76 | 
 77 |   int fullscreen_state = SDL_GetWindowFlags(win) & SDL_WINDOW_FULLSCREEN;
 78 | 
 79 |   SDL_SetWindowFullscreen(win,
 80 |                           fullscreen_state ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP);
 81 |   SDL_ShowCursor(fullscreen_state);
 82 | 
 83 |   dirty = 1;
 84 | }
 85 | 
 86 | int draw_character(struct draw_character_command *command) {
 87 | 
 88 |   uint32_t fgcolor = (command->foreground.r << 16) |
 89 |                      (command->foreground.g << 8) | command->foreground.b;
 90 |   uint32_t bgcolor = (command->background.r << 16) |
 91 |                      (command->background.g << 8) | command->background.b;
 92 | 
 93 |   if (bgcolor == fgcolor) {
 94 |     // When bgcolor and fgcolor are the same, do not render a background
 95 |     inprint(rend, (char *)&command->c, command->pos.x, command->pos.y + 3,
 96 |             fgcolor, -1);
 97 |   } else {
 98 |     inprint(rend, (char *)&command->c, command->pos.x, command->pos.y + 3,
 99 |             fgcolor, bgcolor);
100 |   }
101 | 
102 |   dirty = 1;
103 | 
104 |   return 1;
105 | }
106 | 
107 | void draw_rectangle(struct draw_rectangle_command *command) {
108 | 
109 |   SDL_Rect render_rect;
110 | 
111 |   render_rect.x = command->pos.x;
112 |   render_rect.y = command->pos.y;
113 |   render_rect.h = command->size.height;
114 |   render_rect.w = command->size.width;
115 | 
116 |   // Background color changed
117 |   if (render_rect.x == 0 && render_rect.y == 0 && render_rect.w == 320 &&
118 |       render_rect.h == 240) {
119 |     background_color.r = command->color.r;
120 |     background_color.g = command->color.g;
121 |     background_color.b = command->color.b;
122 |     background_color.a = 0xFF;
123 |   }
124 | 
125 |   SDL_SetRenderDrawColor(rend, command->color.r, command->color.g,
126 |                          command->color.b, 0xFF);
127 |   SDL_RenderFillRect(rend, &render_rect);
128 | 
129 |   dirty = 1;
130 | }
131 | 
132 | void draw_waveform(struct draw_oscilloscope_waveform_command *command) {
133 | 
134 |   static uint8_t wfm_cleared = 0;
135 | 
136 |   // If the waveform is not being displayed and it's already been cleared, skip
137 |   // rendering it
138 |   if (!(wfm_cleared && command->waveform_size == 0)) {
139 | 
140 |     const SDL_Rect wf_rect = {0, 0, 320, 21};
141 | 
142 |     SDL_SetRenderDrawColor(rend, background_color.r, background_color.g,
143 |                            background_color.b, background_color.a);
144 |     SDL_RenderFillRect(rend, &wf_rect);
145 | 
146 |     SDL_SetRenderDrawColor(rend, command->color.r, command->color.g,
147 |                            command->color.b, 255);
148 | 
149 |     // Create a SDL_Point array of the waveform pixels for batch drawing
150 |     SDL_Point waveform_points[command->waveform_size];
151 | 
152 |     for (int i = 0; i < command->waveform_size; i++) {
153 |       // Limit value because the oscilloscope commands seem to glitch
154 |       // occasionally
155 |       if (command->waveform[i] > 20)
156 |         command->waveform[i] = 20;
157 |       waveform_points[i].x = i;
158 |       waveform_points[i].y = command->waveform[i];
159 |     }
160 | 
161 |     SDL_RenderDrawPoints(rend, waveform_points, command->waveform_size);
162 | 
163 |     // The packet we just drew was an empty waveform
164 |     if (command->waveform_size == 0) {
165 |       wfm_cleared = 1;
166 |     } else {
167 |       wfm_cleared = 0;
168 |     }
169 | 
170 |     dirty = 1;
171 |   }
172 | }
173 | 
174 | void display_keyjazz_overlay(uint8_t show, uint8_t base_octave,
175 |                              uint8_t velocity) {
176 | 
177 |   if (show) {
178 |     struct draw_rectangle_command drc;
179 |     drc.color = (struct color){255, 0, 0};
180 |     drc.pos.x = 310;
181 |     drc.pos.y = 230;
182 |     drc.size.width = 5;
183 |     drc.size.height = 5;
184 | 
185 |     draw_rectangle(&drc);
186 | 
187 |     struct draw_character_command dcc;
188 |     dcc.background = (struct color){background_color.r, background_color.g,
189 |                                     background_color.b};
190 |     dcc.foreground = (struct color){200, 200, 200};
191 |     dcc.pos.x = 296;
192 |     dcc.pos.y = 226;
193 | 
194 |     draw_character(&dcc);
195 | 
196 |     char buf[8];
197 |     snprintf(buf, sizeof(buf), "%02X %u", velocity, base_octave);
198 | 
199 |     for (int i = 3; i >= 0; i--) {
200 |       dcc.c = buf[i];
201 |       draw_character(&dcc);
202 |       dcc.pos.x -= 8;
203 |     }
204 | 
205 |   } else {
206 |     struct draw_rectangle_command drc;
207 |     drc.color = (struct color){background_color.r, background_color.g,
208 |                                background_color.b};
209 |     drc.pos.x = 272;
210 |     drc.pos.y = 226;
211 |     drc.size.width = 45;
212 |     drc.size.height = 14;
213 | 
214 |     draw_rectangle(&drc);
215 |   }
216 | 
217 |   dirty = 1;
218 | }
219 | 
220 | void render_screen() {
221 |   if (dirty) {
222 |     dirty = 0;
223 |     //ticks = SDL_GetTicks();
224 |     SDL_SetRenderTarget(rend, NULL);
225 |     SDL_SetRenderDrawColor(rend, 0, 0, 0, 0);
226 |     SDL_RenderClear(rend);
227 |     SDL_RenderCopy(rend, maintexture, NULL, NULL);
228 |     SDL_RenderPresent(rend);
229 |     SDL_SetRenderTarget(rend, maintexture);
230 | 
231 |     fps++;
232 | 
233 |     if (SDL_GetTicks() - ticks_fps > 5000) {
234 |       ticks_fps = SDL_GetTicks();
235 |       SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "%.1f fps\n", (float)fps / 5);
236 |       fps = 0;
237 |     }
238 |   }
239 | }
240 | 
241 | void screensaver_init() {
242 |   fx_cube_init(rend, (SDL_Color){255, 255, 255, 255});
243 |   SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Screensaver initialized");
244 | }
245 | 
246 | void screensaver_draw() {
247 |   fx_cube_update();
248 |   dirty = 1;
249 | }
250 | 
251 | void screensaver_destroy() {
252 |   fx_cube_destroy();
253 |   SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Screensaver destroyed");
254 | }
255 | 


--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 Jonne Kokkonen
  2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
  3 | 
  4 | /* Uncomment this line to enable debug messages or call make with `make
  5 |    CFLAGS=-DDEBUG_MSG` */
  6 | // #define DEBUG_MSG
  7 | 
  8 | #include <SDL.h>
  9 | #include <libserialport.h>
 10 | #include <signal.h>
 11 | 
 12 | #include "command.h"
 13 | #include "config.h"
 14 | #include "input.h"
 15 | #include "render.h"
 16 | #include "serial.h"
 17 | #include "slip.h"
 18 | #include "write.h"
 19 | 
 20 | // maximum amount of bytes to read from the serial in one read()
 21 | #define serial_read_size 324
 22 | 
 23 | enum state { QUIT, WAIT_FOR_DEVICE, RUN };
 24 | 
 25 | enum state run = WAIT_FOR_DEVICE;
 26 | uint8_t need_display_reset = 0;
 27 | 
 28 | // Handles CTRL+C / SIGINT
 29 | void intHandler(int dummy) { run = QUIT; }
 30 | 
 31 | void close_serial_port(struct sp_port *port) {
 32 |   disconnect(port);
 33 |   sp_close(port);
 34 |   sp_free_port(port);
 35 | }
 36 | 
 37 | int main(int argc, char *argv[]) {
 38 |   // Initialize the config to defaults read in the params from the
 39 |   // configfile if present
 40 |   config_params_s conf = init_config();
 41 | 
 42 |   // TODO: take cli parameter to override default configfile location
 43 |   read_config(&conf);
 44 | 
 45 |   // allocate memory for serial buffer
 46 |   uint8_t *serial_buf = malloc(serial_read_size);
 47 | 
 48 |   static uint8_t slip_buffer[serial_read_size]; // SLIP command buffer
 49 | 
 50 |   // settings for the slip packet handler
 51 |   static const slip_descriptor_s slip_descriptor = {
 52 |       .buf = slip_buffer,
 53 |       .buf_size = sizeof(slip_buffer),
 54 |       .recv_message = process_command, // the function where complete slip
 55 |                                        // packets are processed further
 56 |   };
 57 | 
 58 |   static slip_handler_s slip;
 59 |   struct sp_port *port = NULL;
 60 | 
 61 |   uint8_t prev_input = 0;
 62 |   uint8_t prev_note = 0;
 63 |   uint16_t zerobyte_packets = 0; // used to detect device disconnection
 64 | 
 65 |   signal(SIGINT, intHandler);
 66 |   signal(SIGTERM, intHandler);
 67 | 
 68 |   slip_init(&slip, &slip_descriptor);
 69 | 
 70 |   // First device detection to avoid SDL init if it isn't necessary
 71 |   if (conf.wait_for_device == 0) {
 72 |     port = init_serial(1);
 73 |     if (port == NULL) {
 74 |       free(serial_buf);
 75 |       return -1;
 76 |     }
 77 |   }
 78 | 
 79 |   // initialize all SDL systems
 80 |   if (initialize_sdl(conf.init_fullscreen, conf.init_use_gpu) == -1)
 81 |     run = QUIT;
 82 | 
 83 |   // initial scan for (existing) game controllers
 84 |   initialize_game_controllers();
 85 | 
 86 | #ifdef DEBUG_MSG
 87 |   SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 88 | #endif
 89 | 
 90 |   // force disable mouse cursor
 91 |   if (conf.init_disable_cursor) {
 92 |     SDL_ShowCursor(SDL_DISABLE);
 93 |   }
 94 | 
 95 |   // main loop begin
 96 |   do {
 97 |     if (port == NULL)
 98 |       port = init_serial(1);
 99 |     if (port != NULL) {
100 |       int result;
101 |       result = enable_and_reset_display(port);
102 |       if (result == 1) {
103 |         run = RUN;
104 |       } else {
105 |         SDL_LogCritical(SDL_LOG_CATEGORY_ERROR,
106 |                         "Device not detected on begin loop.");
107 |         run = QUIT;
108 |       }
109 |     }
110 | 
111 |     // wait until device is connected
112 |     if (conf.wait_for_device) {
113 |       static uint32_t ticks_poll_device = 0;
114 |       static uint32_t ticks_update_screen = 0;
115 | 
116 |       if (port == NULL)
117 |         screensaver_init();
118 | 
119 |       while (run == WAIT_FOR_DEVICE) {
120 |         // get current inputs
121 |         input_msg_s input = get_input_msg(&conf);
122 |         if (input.type == special && input.value == msg_quit) {
123 |           SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Input message QUIT.");
124 |           run = QUIT;
125 |         }
126 | 
127 |         if (SDL_GetTicks() - ticks_update_screen > 16) {
128 |           ticks_update_screen = SDL_GetTicks();
129 |           screensaver_draw();
130 |           render_screen();
131 |         }
132 | 
133 |         // Poll for M8 device every second
134 |         if (!port && (SDL_GetTicks() - ticks_poll_device > 1000)) {
135 |           ticks_poll_device = SDL_GetTicks();
136 |           port = init_serial(0);
137 |           if (run == WAIT_FOR_DEVICE && port != NULL) {
138 |             int result = enable_and_reset_display(port);
139 |             SDL_Delay(100);
140 |             // Device was found; enable display and proceed to the main loop
141 |             if (result == 1) {
142 |               run = RUN;
143 |               screensaver_destroy();
144 |             } else {
145 |               SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Device not detected.");
146 |               run = QUIT;
147 |               screensaver_destroy();
148 |             }
149 |           }
150 |         }
151 | 
152 |         SDL_Delay(conf.idle_ms);
153 |       }
154 | 
155 |     } else {
156 |       // classic startup behaviour, exit if device is not found
157 |       if (port == NULL) {
158 |         close_game_controllers();
159 |         close_renderer();
160 |         SDL_Quit();
161 |         free(serial_buf);
162 |         return -1;
163 |       }
164 |       render_screen();
165 |     }
166 | 
167 |     // main loop
168 |     while (run == RUN) {
169 | 
170 |       // get current inputs
171 |       input_msg_s input = get_input_msg(&conf);
172 | 
173 |       switch (input.type) {
174 |       case normal:
175 |         if (input.value != prev_input) {
176 |           prev_input = input.value;
177 |           send_msg_controller(port, input.value);
178 |         }
179 |         break;
180 |       case keyjazz:
181 |         if (input.value != 0) {
182 |           if (input.eventType == SDL_KEYDOWN && input.value != prev_input) {
183 |             send_msg_keyjazz(port, input.value, input.value2);
184 |             prev_note = input.value;
185 |           } else if (input.eventType == SDL_KEYUP && input.value == prev_note) {
186 |             send_msg_keyjazz(port, 0xFF, 0);
187 |           }
188 |         }
189 |         prev_input = input.value;
190 |         break;
191 |       case special:
192 |         if (input.value != prev_input) {
193 |           prev_input = input.value;
194 |           switch (input.value) {
195 |           case msg_quit:
196 |             SDL_Log("Received msg_quit from input device.");
197 |             run = 0;
198 |             break;
199 |           case msg_reset_display:
200 |             reset_display(port);
201 |             break;
202 |           default:
203 |             break;
204 |           }
205 |           break;
206 |         }
207 |       }
208 | 
209 |       while (1) {
210 |         // read serial port
211 |         int bytes_read =
212 |             sp_nonblocking_read(port, serial_buf, serial_read_size);
213 |         if (bytes_read < 0) {
214 |           SDL_LogCritical(SDL_LOG_CATEGORY_ERROR, "Error %d reading serial. \n",
215 |                           (int)bytes_read);
216 |           run = QUIT;
217 |           break;
218 |         } else if (bytes_read > 0) {
219 |           // input from device: reset the zero byte counter and create a
220 |           // pointer to the serial buffer
221 |           zerobyte_packets = 0;
222 |           uint8_t *cur = serial_buf;
223 |           const uint8_t *end = serial_buf + bytes_read;
224 |           while (cur < end) {
225 |             // process the incoming bytes into commands and draw them
226 |             int n = slip_read_byte(&slip, *(cur++));
227 |             if (n != SLIP_NO_ERROR) {
228 |               if (n == SLIP_ERROR_INVALID_PACKET) {
229 |                 reset_display(port);
230 |               } else {
231 |                 SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SLIP error %d\n", n);
232 |               }
233 |             }
234 |           }
235 |         } else {
236 |           // zero byte packet, increment counter
237 |           zerobyte_packets++;
238 |           if (zerobyte_packets > conf.wait_packets) {
239 |             zerobyte_packets = 0;
240 | 
241 |             // try opening the serial port to check if it's alive
242 |             if (check_serial_port(port)) {
243 |               // the device is still there, carry on
244 |               break;
245 |             } else {
246 |               run = WAIT_FOR_DEVICE;
247 |               close_serial_port(port);
248 |               port = NULL;
249 |               /* we'll make one more loop to see if the device is still there
250 |                * but just sending zero bytes. if it doesn't get detected when
251 |                * resetting the port, it will disconnect */
252 |             }
253 |           }
254 |           break;
255 |         }
256 |       }
257 |       render_screen();
258 |       SDL_Delay(conf.idle_ms);
259 |     }
260 |   } while (run > QUIT);
261 |   // main loop end
262 | 
263 |   // exit, clean up
264 |   SDL_Log("Shutting down\n");
265 |   close_game_controllers();
266 |   close_renderer();
267 |   close_serial_port(port);
268 |   free(serial_buf);
269 |   SDL_Quit();
270 |   return 0;
271 | }
272 | 


--------------------------------------------------------------------------------
/config.c:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 Jonne Kokkonen
  2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
  3 | 
  4 | #include "config.h"
  5 | #include "ini.h"
  6 | #include <SDL.h>
  7 | #include <assert.h>
  8 | 
  9 | /* Case insensitive string compare from ini.h library */
 10 | static int strcmpci(const char *a, const char *b) {
 11 |   for (;;) {
 12 |     int d = tolower(*a) - tolower(*b);
 13 |     if (d != 0 || !*a) {
 14 |       return d;
 15 |     }
 16 |     a++, b++;
 17 |   }
 18 | }
 19 | 
 20 | config_params_s init_config() {
 21 |   config_params_s c;
 22 | 
 23 |   c.filename = "config.ini"; // default config file to load
 24 | 
 25 |   c.init_fullscreen = 0; // default fullscreen state at load
 26 |   c.init_use_gpu = 1;    // default to use hardware acceleration
 27 |   c.init_disable_cursor = 0;
 28 |   c.idle_ms = 10;        // default to high performance
 29 |   c.wait_for_device = 0; // default to exit if device disconnected
 30 |   c.wait_packets = 1024;   // default zero-byte attempts to disconnect (about 2 sec for default idle_ms)
 31 | 
 32 |   c.key_up = SDL_SCANCODE_UP;
 33 |   c.key_left = SDL_SCANCODE_LEFT;
 34 |   c.key_down = SDL_SCANCODE_DOWN;
 35 |   c.key_right = SDL_SCANCODE_RIGHT;
 36 |   c.key_select = SDL_SCANCODE_LSHIFT;
 37 |   c.key_select_alt = SDL_SCANCODE_A;
 38 |   c.key_start = SDL_SCANCODE_SPACE;
 39 |   c.key_start_alt = SDL_SCANCODE_S;
 40 |   c.key_opt = SDL_SCANCODE_LALT;
 41 |   c.key_opt_alt = SDL_SCANCODE_Z;
 42 |   c.key_edit = SDL_SCANCODE_LCTRL;
 43 |   c.key_edit_alt = SDL_SCANCODE_X;
 44 |   c.key_delete = SDL_SCANCODE_DELETE;
 45 |   c.key_reset = SDL_SCANCODE_R;
 46 | 
 47 |   c.gamepad_up = SDL_CONTROLLER_BUTTON_DPAD_UP;
 48 |   c.gamepad_left = SDL_CONTROLLER_BUTTON_DPAD_LEFT;
 49 |   c.gamepad_down = SDL_CONTROLLER_BUTTON_DPAD_DOWN;
 50 |   c.gamepad_right = SDL_CONTROLLER_BUTTON_DPAD_RIGHT;
 51 |   c.gamepad_select = SDL_CONTROLLER_BUTTON_BACK;
 52 |   c.gamepad_start = SDL_CONTROLLER_BUTTON_START;
 53 |   c.gamepad_opt = SDL_CONTROLLER_BUTTON_B;
 54 |   c.gamepad_edit = SDL_CONTROLLER_BUTTON_A;
 55 |   c.gamepad_quit = SDL_CONTROLLER_BUTTON_RIGHTSTICK;
 56 |   c.gamepad_reset = SDL_CONTROLLER_BUTTON_LEFTSTICK;
 57 | 
 58 |   c.gamepad_analog_threshold = 32766;
 59 |   c.gamepad_analog_invert = 0;
 60 |   c.gamepad_analog_axis_updown = SDL_CONTROLLER_AXIS_LEFTY;
 61 |   c.gamepad_analog_axis_leftright = SDL_CONTROLLER_AXIS_LEFTX;
 62 |   c.gamepad_analog_axis_start = SDL_CONTROLLER_AXIS_TRIGGERRIGHT;
 63 |   c.gamepad_analog_axis_select = SDL_CONTROLLER_AXIS_TRIGGERLEFT;
 64 |   c.gamepad_analog_axis_opt = SDL_CONTROLLER_AXIS_INVALID;
 65 |   c.gamepad_analog_axis_edit = SDL_CONTROLLER_AXIS_INVALID;
 66 | 
 67 |   return c;
 68 | }
 69 | 
 70 | // Write config to file
 71 | void write_config(config_params_s *conf) {
 72 | 
 73 |   // Open the default config file for writing
 74 |   char config_path[1024] = {0};
 75 |   snprintf(config_path, sizeof(config_path), "%s%s", SDL_GetPrefPath("", "m8c"),
 76 |            conf->filename);
 77 |   SDL_RWops *rw = SDL_RWFromFile(config_path, "w");
 78 | 
 79 |   SDL_Log("Writing config file to %s", config_path);
 80 | 
 81 |   const unsigned int INI_LINE_COUNT = 41;
 82 |   const unsigned int LINELEN = 50;
 83 | 
 84 |   // Entries for the config file
 85 |   char ini_values[INI_LINE_COUNT][LINELEN];
 86 |   int initPointer = 0;
 87 |   snprintf(ini_values[initPointer++], LINELEN, "[graphics]\n");
 88 |   snprintf(ini_values[initPointer++], LINELEN, "fullscreen=%s\n",
 89 |            conf->init_fullscreen ? "true" : "false");
 90 |   snprintf(ini_values[initPointer++], LINELEN, "use_gpu=%s\n",
 91 |            conf->init_use_gpu ? "true" : "false");
 92 |   snprintf(ini_values[initPointer++], LINELEN, "idle_ms=%d\n", conf->idle_ms);
 93 |   snprintf(ini_values[initPointer++], LINELEN, "wait_for_device=%s\n",
 94 |            conf->wait_for_device ? "true" : "false");
 95 |   sprintf(ini_values[initPointer++], "disable_cursor=%s\n",
 96 |            conf->init_disable_cursor ? "true" : "false");
 97 |   snprintf(ini_values[initPointer++], LINELEN, "wait_packets=%d\n", conf->wait_packets);
 98 |   snprintf(ini_values[initPointer++], LINELEN, "[keyboard]\n");
 99 |   snprintf(ini_values[initPointer++], LINELEN, "key_up=%d\n", conf->key_up);
100 |   snprintf(ini_values[initPointer++], LINELEN, "key_left=%d\n", conf->key_left);
101 |   snprintf(ini_values[initPointer++], LINELEN, "key_down=%d\n", conf->key_down);
102 |   snprintf(ini_values[initPointer++], LINELEN, "key_right=%d\n",
103 |            conf->key_right);
104 |   snprintf(ini_values[initPointer++], LINELEN, "key_select=%d\n",
105 |            conf->key_select);
106 |   snprintf(ini_values[initPointer++], LINELEN, "key_select_alt=%d\n",
107 |            conf->key_select_alt);
108 |   snprintf(ini_values[initPointer++], LINELEN, "key_start=%d\n",
109 |            conf->key_start);
110 |   snprintf(ini_values[initPointer++], LINELEN, "key_start_alt=%d\n",
111 |            conf->key_start_alt);
112 |   snprintf(ini_values[initPointer++], LINELEN, "key_opt=%d\n", conf->key_opt);
113 |   snprintf(ini_values[initPointer++], LINELEN, "key_opt_alt=%d\n",
114 |            conf->key_opt_alt);
115 |   snprintf(ini_values[initPointer++], LINELEN, "key_edit=%d\n", conf->key_edit);
116 |   snprintf(ini_values[initPointer++], LINELEN, "key_edit_alt=%d\n",
117 |            conf->key_edit_alt);
118 |   snprintf(ini_values[initPointer++], LINELEN, "key_delete=%d\n",
119 |            conf->key_delete);
120 |   snprintf(ini_values[initPointer++], LINELEN, "key_reset=%d\n",
121 |            conf->key_reset);
122 |   snprintf(ini_values[initPointer++], LINELEN, "[gamepad]\n");
123 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_up=%d\n",
124 |            conf->gamepad_up);
125 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_left=%d\n",
126 |            conf->gamepad_left);
127 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_down=%d\n",
128 |            conf->gamepad_down);
129 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_right=%d\n",
130 |            conf->gamepad_right);
131 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_select=%d\n",
132 |            conf->gamepad_select);
133 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_start=%d\n",
134 |            conf->gamepad_start);
135 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_opt=%d\n",
136 |            conf->gamepad_opt);
137 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_edit=%d\n",
138 |            conf->gamepad_edit);
139 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_quit=%d\n",
140 |            conf->gamepad_quit);
141 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_reset=%d\n",
142 |            conf->gamepad_reset);
143 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_analog_threshold=%d\n",
144 |            conf->gamepad_analog_threshold);
145 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_analog_invert=%s\n",
146 |            conf->gamepad_analog_invert ? "true" : "false");
147 |   snprintf(ini_values[initPointer++], LINELEN,
148 |            "gamepad_analog_axis_updown=%d\n", conf->gamepad_analog_axis_updown);
149 |   snprintf(ini_values[initPointer++], LINELEN,
150 |            "gamepad_analog_axis_leftright=%d\n",
151 |            conf->gamepad_analog_axis_leftright);
152 |   snprintf(ini_values[initPointer++], LINELEN,
153 |            "gamepad_analog_axis_select=%d\n", conf->gamepad_analog_axis_select);
154 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_analog_axis_start=%d\n",
155 |            conf->gamepad_analog_axis_start);
156 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_analog_axis_opt=%d\n",
157 |            conf->gamepad_analog_axis_opt);
158 |   snprintf(ini_values[initPointer++], LINELEN, "gamepad_analog_axis_edit=%d\n",
159 |            conf->gamepad_analog_axis_edit);
160 | 
161 |   // Ensure we aren't writing off the end of the array
162 |   assert(initPointer == INI_LINE_COUNT);
163 | 
164 |   if (rw != NULL) {
165 |     // Write ini_values array to config file
166 |     for (int i = 0; i < INI_LINE_COUNT; i++) {
167 |       size_t len = SDL_strlen(ini_values[i]);
168 |       if (SDL_RWwrite(rw, ini_values[i], 1, len) != len) {
169 |         SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM,
170 |                      "Couldn't write line into config file.");
171 |       } else {
172 |         SDL_LogDebug(SDL_LOG_CATEGORY_SYSTEM, "Wrote to config: %s",
173 |                      ini_values[i]);
174 |       }
175 |     }
176 |     SDL_RWclose(rw);
177 |   } else {
178 |     SDL_Log("Couldn't write into config file.");
179 |   }
180 | }
181 | 
182 | // Read config
183 | void read_config(config_params_s *conf) {
184 | 
185 |   char config_path[1024] = {0};
186 |   snprintf(config_path, sizeof(config_path), "%s%s", SDL_GetPrefPath("", "m8c"),
187 |            conf->filename);
188 |   SDL_Log("Reading config %s", config_path);
189 |   ini_t *ini = ini_load(config_path);
190 |   if (ini == NULL) {
191 |     SDL_Log("Could not load config.");
192 |     write_config(conf);
193 |     return;
194 |   }
195 | 
196 |   read_graphics_config(ini, conf);
197 |   read_key_config(ini, conf);
198 |   read_gamepad_config(ini, conf);
199 | 
200 |   // Frees the mem used for the config
201 |   ini_free(ini);
202 | 
203 |   // Write any new default options after loading
204 |   write_config(conf);
205 | }
206 | 
207 | void read_graphics_config(ini_t *ini, config_params_s *conf) {
208 |   const char *param_fs = ini_get(ini, "graphics", "fullscreen");
209 |   const char *param_gpu = ini_get(ini, "graphics", "use_gpu");
210 |   const char *param_cursor = ini_get(ini, "graphics", "disable_cursor");
211 |   const char *idle_ms = ini_get(ini, "graphics", "idle_ms");
212 |   const char *param_wait = ini_get(ini, "graphics", "wait_for_device");
213 |   const char *wait_packets = ini_get(ini, "graphics", "wait_packets");
214 | 
215 |   if(param_gpu != NULL){
216 |     if (strcmpci(param_fs, "true") == 0) {
217 |       conf->init_fullscreen = 1;
218 |     } else
219 |       conf->init_fullscreen = 0;
220 |   }
221 | 
222 |   if (strcmpci(param_fs, "true") == 0) {
223 |     conf->init_fullscreen = 1;
224 |   } else
225 |     conf->init_fullscreen = 0;
226 | 
227 |   if (param_gpu != NULL) {
228 |     if (strcmpci(param_gpu, "true") == 0) {
229 |       conf->init_use_gpu = 1;
230 |     } else
231 |       conf->init_use_gpu = 0;
232 |   }
233 | 
234 |   if(param_cursor != NULL){
235 |     if (strcmpci(param_cursor, "true") == 0) {
236 |       conf->init_disable_cursor = 1;
237 |     } else
238 |       conf->init_disable_cursor = 0;
239 |   }
240 | 
241 |   if (idle_ms != NULL)
242 |     conf->idle_ms = SDL_atoi(idle_ms);
243 | 
244 |   if (param_wait != NULL) {
245 |     if (strcmpci(param_wait, "true") == 0) {
246 |       conf->wait_for_device = 1;
247 |     } else {
248 |       conf->wait_for_device = 0;
249 |     }
250 |   }
251 |   if (wait_packets != NULL)
252 |     conf->wait_packets = SDL_atoi(wait_packets);
253 | }
254 | 
255 | void read_key_config(ini_t *ini, config_params_s *conf) {
256 |   // TODO: Some form of validation
257 | 
258 |   const char *key_up = ini_get(ini, "keyboard", "key_up");
259 |   const char *key_left = ini_get(ini, "keyboard", "key_left");
260 |   const char *key_down = ini_get(ini, "keyboard", "key_down");
261 |   const char *key_right = ini_get(ini, "keyboard", "key_right");
262 |   const char *key_select = ini_get(ini, "keyboard", "key_select");
263 |   const char *key_select_alt = ini_get(ini, "keyboard", "key_select_alt");
264 |   const char *key_start = ini_get(ini, "keyboard", "key_start");
265 |   const char *key_start_alt = ini_get(ini, "keyboard", "key_start_alt");
266 |   const char *key_opt = ini_get(ini, "keyboard", "key_opt");
267 |   const char *key_opt_alt = ini_get(ini, "keyboard", "key_opt_alt");
268 |   const char *key_edit = ini_get(ini, "keyboard", "key_edit");
269 |   const char *key_edit_alt = ini_get(ini, "keyboard", "key_edit_alt");
270 |   const char *key_delete = ini_get(ini, "keyboard", "key_delete");
271 |   const char *key_reset = ini_get(ini, "keyboard", "key_reset");
272 | 
273 |   if (key_up)
274 |     conf->key_up = SDL_atoi(key_up);
275 |   if (key_left)
276 |     conf->key_left = SDL_atoi(key_left);
277 |   if (key_down)
278 |     conf->key_down = SDL_atoi(key_down);
279 |   if (key_right)
280 |     conf->key_right = SDL_atoi(key_right);
281 |   if (key_select)
282 |     conf->key_select = SDL_atoi(key_select);
283 |   if (key_select_alt)
284 |     conf->key_select_alt = SDL_atoi(key_select_alt);
285 |   if (key_start)
286 |     conf->key_start = SDL_atoi(key_start);
287 |   if (key_start_alt)
288 |     conf->key_start_alt = SDL_atoi(key_start_alt);
289 |   if (key_opt)
290 |     conf->key_opt = SDL_atoi(key_opt);
291 |   if (key_opt_alt)
292 |     conf->key_opt_alt = SDL_atoi(key_opt_alt);
293 |   if (key_edit)
294 |     conf->key_edit = SDL_atoi(key_edit);
295 |   if (key_edit_alt)
296 |     conf->key_edit_alt = SDL_atoi(key_edit_alt);
297 |   if (key_delete)
298 |     conf->key_delete = SDL_atoi(key_delete);
299 |   if (key_reset)
300 |     conf->key_reset = SDL_atoi(key_reset);
301 | }
302 | 
303 | void read_gamepad_config(ini_t *ini, config_params_s *conf) {
304 |   // TODO: Some form of validation
305 | 
306 |   const char *gamepad_up = ini_get(ini, "gamepad", "gamepad_up");
307 |   const char *gamepad_left = ini_get(ini, "gamepad", "gamepad_left");
308 |   const char *gamepad_down = ini_get(ini, "gamepad", "gamepad_down");
309 |   const char *gamepad_right = ini_get(ini, "gamepad", "gamepad_right");
310 |   const char *gamepad_select = ini_get(ini, "gamepad", "gamepad_select");
311 |   const char *gamepad_start = ini_get(ini, "gamepad", "gamepad_start");
312 |   const char *gamepad_opt = ini_get(ini, "gamepad", "gamepad_opt");
313 |   const char *gamepad_edit = ini_get(ini, "gamepad", "gamepad_edit");
314 |   const char *gamepad_quit = ini_get(ini, "gamepad", "gamepad_quit");
315 |   const char *gamepad_reset = ini_get(ini, "gamepad", "gamepad_reset");
316 |   const char *gamepad_analog_threshold =
317 |       ini_get(ini, "gamepad", "gamepad_analog_threshold");
318 |   const char *gamepad_analog_invert =
319 |       ini_get(ini, "gamepad", "gamepad_analog_invert");
320 |   const char *gamepad_analog_axis_updown =
321 |       ini_get(ini, "gamepad", "gamepad_analog_axis_updown");
322 |   const char *gamepad_analog_axis_leftright =
323 |       ini_get(ini, "gamepad", "gamepad_analog_axis_leftright");
324 |   const char *gamepad_analog_axis_select =
325 |       ini_get(ini, "gamepad", "gamepad_analog_axis_select");
326 |   const char *gamepad_analog_axis_start =
327 |       ini_get(ini, "gamepad", "gamepad_analog_axis_start");
328 |   const char *gamepad_analog_axis_opt =
329 |       ini_get(ini, "gamepad", "gamepad_analog_axis_opt");
330 |   const char *gamepad_analog_axis_edit =
331 |       ini_get(ini, "gamepad", "gamepad_analog_axis_edit");
332 | 
333 |   if (gamepad_up)
334 |     conf->gamepad_up = SDL_atoi(gamepad_up);
335 |   if (gamepad_left)
336 |     conf->gamepad_left = SDL_atoi(gamepad_left);
337 |   if (gamepad_down)
338 |     conf->gamepad_down = SDL_atoi(gamepad_down);
339 |   if (gamepad_right)
340 |     conf->gamepad_right = SDL_atoi(gamepad_right);
341 |   if (gamepad_select)
342 |     conf->gamepad_select = SDL_atoi(gamepad_select);
343 |   if (gamepad_start)
344 |     conf->gamepad_start = SDL_atoi(gamepad_start);
345 |   if (gamepad_opt)
346 |     conf->gamepad_opt = SDL_atoi(gamepad_opt);
347 |   if (gamepad_edit)
348 |     conf->gamepad_edit = SDL_atoi(gamepad_edit);
349 |   if (gamepad_quit)
350 |     conf->gamepad_quit = SDL_atoi(gamepad_quit);
351 |   if (gamepad_reset)
352 |     conf->gamepad_reset = SDL_atoi(gamepad_reset);
353 |   if (gamepad_analog_threshold)
354 |     conf->gamepad_analog_threshold = SDL_atoi(gamepad_analog_threshold);
355 | 
356 |   if (strcmpci(gamepad_analog_invert, "true") == 0)
357 |     conf->gamepad_analog_invert = 1;
358 |   else
359 |     conf->gamepad_analog_invert = 0;
360 | 
361 |   if (gamepad_analog_axis_updown)
362 |     conf->gamepad_analog_axis_updown = SDL_atoi(gamepad_analog_axis_updown);
363 |   if (gamepad_analog_axis_leftright)
364 |     conf->gamepad_analog_axis_leftright =
365 |         SDL_atoi(gamepad_analog_axis_leftright);
366 |   if (gamepad_analog_axis_select)
367 |     conf->gamepad_analog_axis_select = SDL_atoi(gamepad_analog_axis_select);
368 |   if (gamepad_analog_axis_start)
369 |     conf->gamepad_analog_axis_start = SDL_atoi(gamepad_analog_axis_start);
370 |   if (gamepad_analog_axis_opt)
371 |     conf->gamepad_analog_axis_opt = SDL_atoi(gamepad_analog_axis_opt);
372 |   if (gamepad_analog_axis_edit)
373 |     conf->gamepad_analog_axis_edit = SDL_atoi(gamepad_analog_axis_edit);
374 | }
375 | 


--------------------------------------------------------------------------------
/input.c:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 Jonne Kokkonen
  2 | // Released under the MIT licence, https://opensource.org/licenses/MIT
  3 | 
  4 | #include <SDL.h>
  5 | #include <stdio.h>
  6 | 
  7 | #include "config.h"
  8 | #include "input.h"
  9 | #include "render.h"
 10 | #include "write.h"
 11 | 
 12 | #define MAX_CONTROLLERS 4
 13 | 
 14 | SDL_GameController *game_controllers[MAX_CONTROLLERS];
 15 | 
 16 | // Bits for M8 input messages
 17 | enum keycodes {
 18 |   key_left = 1 << 7,
 19 |   key_up = 1 << 6,
 20 |   key_down = 1 << 5,
 21 |   key_select = 1 << 4,
 22 |   key_start = 1 << 3,
 23 |   key_right = 1 << 2,
 24 |   key_opt = 1 << 1,
 25 |   key_edit = 1
 26 | };
 27 | 
 28 | uint8_t keyjazz_enabled = 0;
 29 | uint8_t keyjazz_base_octave = 2;
 30 | uint8_t keyjazz_velocity = 0x64;
 31 | 
 32 | static uint8_t keycode = 0; // value of the pressed key
 33 | static int num_joysticks = 0;
 34 | 
 35 | input_msg_s key = {normal, 0};
 36 | 
 37 | uint8_t toggle_input_keyjazz() {
 38 |   keyjazz_enabled = !keyjazz_enabled;
 39 |   return keyjazz_enabled;
 40 | }
 41 | 
 42 | // Opens available game controllers and returns the amount of opened controllers
 43 | int initialize_game_controllers() {
 44 | 
 45 |   num_joysticks = SDL_NumJoysticks();
 46 |   int controller_index = 0;
 47 | 
 48 |   SDL_Log("Looking for game controllers\n");
 49 |   SDL_Delay(
 50 |       10); // Some controllers like XBone wired need a little while to get ready
 51 | 
 52 |   // Try to load the game controller database file
 53 |   char db_filename[1024] = {0};
 54 |   snprintf(db_filename, sizeof(db_filename), "%sgamecontrollerdb.txt",
 55 |            SDL_GetPrefPath("", "m8c"));
 56 |   SDL_Log("Trying to open game controller database from %s", db_filename);
 57 |   SDL_RWops* db_rw = SDL_RWFromFile(db_filename, "rb");
 58 |   if (db_rw == NULL) {
 59 |     snprintf(db_filename, sizeof(db_filename), "%sgamecontrollerdb.txt",
 60 |     SDL_GetBasePath());
 61 |     SDL_Log("Trying to open game controller database from %s", db_filename);
 62 |     db_rw = SDL_RWFromFile(db_filename, "rb");
 63 |   }
 64 | 
 65 |   if (db_rw != NULL) {
 66 |     int mappings = SDL_GameControllerAddMappingsFromRW(db_rw, 1);
 67 |     if (mappings != -1)
 68 |       SDL_Log("Found %d game controller mappings", mappings);
 69 |     else
 70 |       SDL_LogError(SDL_LOG_CATEGORY_INPUT,
 71 |                    "Error loading game controller mappings.");
 72 |   } else {
 73 |     SDL_LogError(SDL_LOG_CATEGORY_INPUT,
 74 |                  "Unable to open game controller database file.");
 75 |   }
 76 | 
 77 |   // Open all available game controllers
 78 |   for (int i = 0; i < num_joysticks; i++) {
 79 |     if (!SDL_IsGameController(i))
 80 |       continue;
 81 |     if (controller_index >= MAX_CONTROLLERS)
 82 |       break;
 83 |     game_controllers[controller_index] = SDL_GameControllerOpen(i);
 84 |     SDL_Log("Controller %d: %s", controller_index + 1,
 85 |             SDL_GameControllerName(game_controllers[controller_index]));
 86 |     controller_index++;
 87 |   }
 88 | 
 89 |   return controller_index;
 90 | }
 91 | 
 92 | // Closes all open game controllers
 93 | void close_game_controllers() {
 94 | 
 95 |   for (int i = 0; i < MAX_CONTROLLERS; i++) {
 96 |     if (game_controllers[i])
 97 |       SDL_GameControllerClose(game_controllers[i]);
 98 |   }
 99 | }
100 | 
101 | static input_msg_s handle_keyjazz(SDL_Event *event, uint8_t keyvalue) {
102 |   input_msg_s key = {keyjazz, keyvalue, keyjazz_velocity, event->type};
103 |   switch (event->key.keysym.scancode) {
104 |   case SDL_SCANCODE_Z:
105 |     key.value = keyjazz_base_octave * 12;
106 |     break;
107 |   case SDL_SCANCODE_S:
108 |     key.value = 1 + keyjazz_base_octave * 12;
109 |     break;
110 |   case SDL_SCANCODE_X:
111 |     key.value = 2 + keyjazz_base_octave * 12;
112 |     break;
113 |   case SDL_SCANCODE_D:
114 |     key.value = 3 + keyjazz_base_octave * 12;
115 |     break;
116 |   case SDL_SCANCODE_C:
117 |     key.value = 4 + keyjazz_base_octave * 12;
118 |     break;
119 |   case SDL_SCANCODE_V:
120 |     key.value = 5 + keyjazz_base_octave * 12;
121 |     break;
122 |   case SDL_SCANCODE_G:
123 |     key.value = 6 + keyjazz_base_octave * 12;
124 |     break;
125 |   case SDL_SCANCODE_B:
126 |     key.value = 7 + keyjazz_base_octave * 12;
127 |     break;
128 |   case SDL_SCANCODE_H:
129 |     key.value = 8 + keyjazz_base_octave * 12;
130 |     break;
131 |   case SDL_SCANCODE_N:
132 |     key.value = 9 + keyjazz_base_octave * 12;
133 |     break;
134 |   case SDL_SCANCODE_J:
135 |     key.value = 10 + keyjazz_base_octave * 12;
136 |     break;
137 |   case SDL_SCANCODE_M:
138 |     key.value = 11 + keyjazz_base_octave * 12;
139 |     break;
140 |   case SDL_SCANCODE_Q:
141 |     key.value = 12 + keyjazz_base_octave * 12;
142 |     break;
143 |   case SDL_SCANCODE_2:
144 |     key.value = 13 + keyjazz_base_octave * 12;
145 |     break;
146 |   case SDL_SCANCODE_W:
147 |     key.value = 14 + keyjazz_base_octave * 12;
148 |     break;
149 |   case SDL_SCANCODE_3:
150 |     key.value = 15 + keyjazz_base_octave * 12;
151 |     break;
152 |   case SDL_SCANCODE_E:
153 |     key.value = 16 + keyjazz_base_octave * 12;
154 |     break;
155 |   case SDL_SCANCODE_R:
156 |     key.value = 17 + keyjazz_base_octave * 12;
157 |     break;
158 |   case SDL_SCANCODE_5:
159 |     key.value = 18 + keyjazz_base_octave * 12;
160 |     break;
161 |   case SDL_SCANCODE_T:
162 |     key.value = 19 + keyjazz_base_octave * 12;
163 |     break;
164 |   case SDL_SCANCODE_6:
165 |     key.value = 20 + keyjazz_base_octave * 12;
166 |     break;
167 |   case SDL_SCANCODE_Y:
168 |     key.value = 21 + keyjazz_base_octave * 12;
169 |     break;
170 |   case SDL_SCANCODE_7:
171 |     key.value = 22 + keyjazz_base_octave * 12;
172 |     break;
173 |   case SDL_SCANCODE_U:
174 |     key.value = 23 + keyjazz_base_octave * 12;
175 |     break;
176 |   case SDL_SCANCODE_I:
177 |     key.value = 24 + keyjazz_base_octave * 12;
178 |     break;
179 |   case SDL_SCANCODE_9:
180 |     key.value = 25 + keyjazz_base_octave * 12;
181 |     break;
182 |   case SDL_SCANCODE_O:
183 |     key.value = 26 + keyjazz_base_octave * 12;
184 |     break;
185 |   case SDL_SCANCODE_0:
186 |     key.value = 27 + keyjazz_base_octave * 12;
187 |     break;
188 |   case SDL_SCANCODE_P:
189 |     key.value = 28 + keyjazz_base_octave * 12;
190 |     break;
191 |   case SDL_SCANCODE_KP_DIVIDE:
192 |     key.type = normal;
193 |     if (event->type == SDL_KEYDOWN && keyjazz_base_octave > 0) {
194 |       keyjazz_base_octave--;
195 |       display_keyjazz_overlay(1, keyjazz_base_octave, keyjazz_velocity);
196 |     }
197 |     break;
198 |   case SDL_SCANCODE_KP_MULTIPLY:
199 |     key.type = normal;
200 |     if (event->type == SDL_KEYDOWN && keyjazz_base_octave < 8) {
201 |       keyjazz_base_octave++;
202 |       display_keyjazz_overlay(1, keyjazz_base_octave, keyjazz_velocity);
203 |     }
204 |     break;
205 |   case SDL_SCANCODE_KP_MINUS:
206 |     key.type = normal;
207 |     if (event->type == SDL_KEYDOWN) {
208 |       if ((event->key.keysym.mod & KMOD_ALT) > 0) {
209 |         if (keyjazz_velocity > 1)
210 |           keyjazz_velocity -= 1;
211 |       } else {
212 |         if (keyjazz_velocity > 0x10)
213 |           keyjazz_velocity -= 0x10;
214 |       }
215 |       display_keyjazz_overlay(1, keyjazz_base_octave, keyjazz_velocity);
216 |     }
217 |     break;
218 |   case SDL_SCANCODE_KP_PLUS:
219 |     key.type = normal;
220 |     if (event->type == SDL_KEYDOWN) {
221 |       if ((event->key.keysym.mod & KMOD_ALT) > 0) {
222 |         if (keyjazz_velocity < 0x7F)
223 |           keyjazz_velocity += 1;
224 |       } else {
225 |         if (keyjazz_velocity < 0x6F)
226 |           keyjazz_velocity += 0x10;
227 |       }
228 |       display_keyjazz_overlay(1, keyjazz_base_octave, keyjazz_velocity);
229 |     }
230 |     break;
231 |   default:
232 |     key.type = normal;
233 |     break;
234 |   }
235 | 
236 |   return key;
237 | }
238 | 
239 | static input_msg_s handle_normal_keys(SDL_Event *event, config_params_s *conf,
240 |                                       uint8_t keyvalue) {
241 |   input_msg_s key = {normal, keyvalue};
242 | 
243 |   if (event->key.keysym.scancode == conf->key_up) {
244 |     key.value = key_up;
245 |   } else if (event->key.keysym.scancode == conf->key_left) {
246 |     key.value = key_left;
247 |   } else if (event->key.keysym.scancode == conf->key_down) {
248 |     key.value = key_down;
249 |   } else if (event->key.keysym.scancode == conf->key_right) {
250 |     key.value = key_right;
251 |   } else if (event->key.keysym.scancode == conf->key_select ||
252 |              event->key.keysym.scancode == conf->key_select_alt) {
253 |     key.value = key_select;
254 |   } else if (event->key.keysym.scancode == conf->key_start ||
255 |              event->key.keysym.scancode == conf->key_start_alt) {
256 |     key.value = key_start;
257 |   } else if (event->key.keysym.scancode == conf->key_opt ||
258 |              event->key.keysym.scancode == conf->key_opt_alt) {
259 |     key.value = key_opt;
260 |   } else if (event->key.keysym.scancode == conf->key_edit ||
261 |              event->key.keysym.scancode == conf->key_edit_alt) {
262 |     key.value = key_edit;
263 |   } else if (event->key.keysym.scancode == conf->key_delete) {
264 |     key.value = key_opt | key_edit;
265 |   } else if (event->key.keysym.scancode == conf->key_reset) {
266 |     key = (input_msg_s){special, msg_reset_display};
267 |   } else {
268 |     key.value = 0;
269 |   }
270 |   return key;
271 | }
272 | 
273 | // Check whether a button is pressed on a gamepad and return 1 if pressed.
274 | static int get_game_controller_button(config_params_s *conf,
275 |                                       SDL_GameController *controller,
276 |                                       int button) {
277 | 
278 |   const int button_mappings[8] = {conf->gamepad_up,     conf->gamepad_down,
279 |                                   conf->gamepad_left,   conf->gamepad_right,
280 |                                   conf->gamepad_opt,    conf->gamepad_edit,
281 |                                   conf->gamepad_select, conf->gamepad_start};
282 | 
283 |   // Check digital buttons
284 |   if (SDL_GameControllerGetButton(controller, button_mappings[button])) {
285 |     return 1;
286 |   } else {
287 |     // If digital button isn't pressed, check the corresponding analog control
288 |     switch (button) {
289 |     case INPUT_UP:
290 |       return SDL_GameControllerGetAxis(controller,
291 |                                        conf->gamepad_analog_axis_updown) <
292 |              -conf->gamepad_analog_threshold;
293 |     case INPUT_DOWN:
294 |       return SDL_GameControllerGetAxis(controller,
295 |                                        conf->gamepad_analog_axis_updown) >
296 |              conf->gamepad_analog_threshold;
297 |     case INPUT_LEFT:
298 |       return SDL_GameControllerGetAxis(controller,
299 |                                        conf->gamepad_analog_axis_leftright) <
300 |              -conf->gamepad_analog_threshold;
301 |     case INPUT_RIGHT:
302 |       return SDL_GameControllerGetAxis(controller,
303 |                                        conf->gamepad_analog_axis_leftright) >
304 |              conf->gamepad_analog_threshold;
305 |     case INPUT_OPT:
306 |       return SDL_GameControllerGetAxis(controller,
307 |                                        conf->gamepad_analog_axis_opt) >
308 |              conf->gamepad_analog_threshold;
309 |     case INPUT_EDIT:
310 |       return SDL_GameControllerGetAxis(controller,
311 |                                        conf->gamepad_analog_axis_edit) >
312 |              conf->gamepad_analog_threshold;
313 |     case INPUT_SELECT:
314 |       return SDL_GameControllerGetAxis(controller,
315 |                                        conf->gamepad_analog_axis_select) >
316 |              conf->gamepad_analog_threshold;
317 |     case INPUT_START:
318 |       return SDL_GameControllerGetAxis(controller,
319 |                                        conf->gamepad_analog_axis_start) >
320 |              conf->gamepad_analog_threshold;
321 |     default:
322 |       return 0;
323 |     }
324 |   }
325 |   return 0;
326 | }
327 | 
328 | // Handle game controllers, simply check all buttons and analog axis on every
329 | // cycle
330 | static int handle_game_controller_buttons(config_params_s *conf) {
331 | 
332 |   const int keycodes[8] = {key_up,  key_down, key_left,   key_right,
333 |                            key_opt, key_edit, key_select, key_start};
334 | 
335 |   int key = 0;
336 | 
337 |   // Cycle through every active game controller
338 |   for (int gc = 0; gc < num_joysticks; gc++) {
339 |     // Cycle through all M8 buttons
340 |     for (int button = 0; button < (input_buttons_t)INPUT_MAX; button++) {
341 |       // If the button is active, add the keycode to the variable containing
342 |       // active keys
343 |       if (get_game_controller_button(conf, game_controllers[gc], button)) {
344 |         key |= keycodes[button];
345 |       }
346 |     }
347 |   }
348 | 
349 |   return key;
350 | }
351 | 
352 | // Handles SDL input events
353 | void handle_sdl_events(config_params_s *conf) {
354 | 
355 |   static int prev_key_analog = 0;
356 | 
357 |   SDL_Event event;
358 | 
359 |   // Read joysticks
360 |   int key_analog = handle_game_controller_buttons(conf);
361 |   if (prev_key_analog != key_analog) {
362 |     keycode = key_analog;
363 |     prev_key_analog = key_analog;
364 |   }
365 | 
366 |   // Read special case game controller buttons quit and reset
367 |   for (int gc = 0; gc < num_joysticks; gc++) {
368 |     if (SDL_GameControllerGetButton(game_controllers[gc], conf->gamepad_quit) && 
369 |         (SDL_GameControllerGetButton(game_controllers[gc], conf->gamepad_select) || 
370 |         SDL_GameControllerGetAxis(game_controllers[gc], conf->gamepad_analog_axis_select)))
371 |       key = (input_msg_s){special, msg_quit};
372 |     else if (SDL_GameControllerGetButton(game_controllers[gc], conf->gamepad_reset) && 
373 |             (SDL_GameControllerGetButton(game_controllers[gc], conf->gamepad_select) || 
374 |               SDL_GameControllerGetAxis(game_controllers[gc], conf->gamepad_analog_axis_select)))
375 |       key = (input_msg_s){special, msg_reset_display};
376 |   }
377 | 
378 |   SDL_PollEvent(&event);
379 | 
380 |   switch (event.type) {
381 | 
382 |   // Reinitialize game controllers on controller add/remove/remap
383 |   case SDL_CONTROLLERDEVICEADDED:
384 |   case SDL_CONTROLLERDEVICEREMOVED:
385 |     initialize_game_controllers();
386 |     break;
387 | 
388 |   // Handle SDL quit events (for example, window close)
389 |   case SDL_QUIT:
390 |     key = (input_msg_s){special, msg_quit};
391 |     break;
392 | 
393 |   case SDL_WINDOWEVENT:
394 |     if (event.window.event == SDL_WINDOWEVENT_RESIZED)
395 |     {
396 |       SDL_Log("Resizing window...");
397 |       key = (input_msg_s){special, msg_reset_display};      
398 |     }
399 |     break;
400 | 
401 |   // Keyboard events. Special events are handled within SDL_KEYDOWN.
402 |   case SDL_KEYDOWN:
403 | 
404 |     // ALT+ENTER toggles fullscreen
405 |     if (event.key.keysym.sym == SDLK_RETURN &&
406 |         (event.key.keysym.mod & KMOD_ALT) > 0) {
407 |       toggle_fullscreen();
408 |       break;
409 |     }
410 | 
411 |     // ALT+F4 quits program
412 |     if (event.key.keysym.sym == SDLK_F4 &&
413 |         (event.key.keysym.mod & KMOD_ALT) > 0) {
414 |       key = (input_msg_s){special, msg_quit};
415 |       break;
416 |     }
417 | 
418 |     // ESC = toggle keyjazz
419 |     if (event.key.keysym.sym == SDLK_ESCAPE) {
420 |       display_keyjazz_overlay(toggle_input_keyjazz(), keyjazz_base_octave, keyjazz_velocity);
421 |     }
422 | 
423 |   // Normal keyboard inputs
424 |   case SDL_KEYUP:
425 |     key = handle_normal_keys(&event, conf, 0);
426 | 
427 |     if (keyjazz_enabled)
428 |       key = handle_keyjazz(&event, key.value);
429 |     break;
430 | 
431 |   default:
432 |     break;
433 |   }
434 | 
435 |   switch (key.type) {
436 |   case normal:
437 |     if (event.type == SDL_KEYDOWN) {
438 |       keycode |= key.value;
439 |     } else {
440 |       keycode &= ~key.value;
441 |     }
442 |     break;
443 |   case keyjazz:
444 |     // Do not allow pressing multiple keys with keyjazz
445 |   case special:
446 |     if (event.type == SDL_KEYDOWN) {
447 |       keycode = key.value;
448 |     } else {
449 |       keycode = 0;
450 |     }
451 |     break;
452 |   default:
453 |     break;
454 |   }
455 | }
456 | 
457 | // Returns the currently pressed keys to main
458 | input_msg_s get_input_msg(config_params_s *conf) {
459 | 
460 |   key = (input_msg_s){normal, 0};
461 | 
462 |   // Query for SDL events
463 |   handle_sdl_events(conf);
464 | 
465 |   if (keycode == (key_start | key_select | key_opt | key_edit)) {
466 |     key = (input_msg_s){special, msg_reset_display};
467 |   }
468 | 
469 |   // additional special button combinations
470 |   if (keycode == (key_select | key_opt | key_up)) {
471 |     key = (input_msg_s){special, msg_reset_display};
472 |   }  
473 |   if (keycode == (key_select | key_opt | key_down)) {
474 |     key = (input_msg_s){special, msg_quit};
475 |   }
476 | 
477 |   if (key.type == normal) {
478 |     /* Normal input keys go through some event-based manipulation in
479 |        handle_sdl_events(), the value is stored in keycode variable */
480 |     return (input_msg_s){key.type, keycode};
481 |   } else {
482 |     // Special event keys already have the correct keycode baked in
483 |     return key;
484 |   }
485 | }
486 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # m8c-piboy
  2 | 
  3 | Changes (hacks) to the [m8c M8 tracker client](https://github.com/laamaa/m8c) for use on
  4 | - PiBoy DMG
  5 |   - Tested on Raspberry Pi 3 B+ with RetroPie v4.7.1
  6 |   - Tested on Raspberry Pi 4 B with the official [PiBoy DMG Image](https://experimentalpi.com/downloads.html).
  7 | - WaveShare Game HAT
  8 |   - Tested on Raspberry Pi 3 B+ with RetroPie v4.8.
  9 | - a plain old Raspberry Pi 3 B+ with RetroPie v4.8.
 10 | 
 11 | Let's all enjoy the M8 software in a LSDJ/GameBoy style, while we wait for the official M8 hardware (support Dirtywave, [go pre-order one](https://dirtywave.com/products/m8-tracker))!
 12 | 
 13 | See it in action here https://www.youtube.com/watch?v=wgCUPZheRhA
 14 | 
 15 | # Introduction (from [laamaa](https://github.com/laamaa))
 16 | 
 17 | The [Dirtywave M8 Tracker](https://dirtywave.com/products/m8-tracker) is a portable sequencer and synthesizer, featuring 8 tracks of assignable instruments such as FM, waveform synthesis, virtual analog, sample playback, and MIDI output. It is powered by a [Teensy](https://www.pjrc.com/teensy/) micro-controller and inspired by the Gameboy tracker [Little Sound DJ](https://www.littlesounddj.com/lsd/index.php).
 18 | 
 19 | While Dirtywave makes new batches of units available on a regular basis, M8 is sometimes sold out due to the worldwide chip shortage and high demand of the unit. To fill this gap and and to allow users to freely test this wonderful tracker, [Timothy Lamb](https://github.com/trash80) was kind enough to make the [M8 Headless](https://github.com/Dirtywave/M8HeadlessFirmware) available to everyone.
 20 | 
 21 | If you like the M8 and you gel with the tracker workflow, please support [Dirtywave](https://dirtywave.com/) by purchasing the actual unit. You can check its availability [here](https://dirtywave.com/products/m8-tracker). Meanwhile, you can also subscribe to Timothy Lamb's [Patreon](https://www.patreon.com/trash80).
 22 | 
 23 | *m8c* is a client for Dirtywave M8 tracker's headless mode. *m8c-piboy* is a fork of *m8c* for running on PiBoy-DMG, WaveShare Game HAT, and other hardware configurations running RetroPie.
 24 | 
 25 | ### Notable changes
 26 | - [add SDL controller line for PiBoy DMG to gamecontrollerdb.txt](https://github.com/rasprague/m8c-piboy/commit/7e59edb765d3f883a72e8de655d1eea0271f27e7)
 27 | - [add game controller line for Waveshare Game HAT](https://github.com/rasprague/m8c-piboy/commit/4318ff1807f902c41fb0e88e37bf56413f16675e)
 28 | - [add m8c startup shell scripts](https://github.com/rasprague/m8c-piboy/commit/f0b0909de3c5786992d8b540f5d09f841aeb7e33)
 29 | - [add two button combinations](https://github.com/rasprague/m8c-piboy/commit/0824b32c62525132de2850b9acddffaf9ea78fff)
 30 |   - select + opt + up = reset display
 31 |   - select + opt + down = quit program
 32 | - [add disable_cursor option to config](https://github.com/rasprague/m8c-piboy/commit/6844d93705db2d0330ded2f62bad6b60b798af90)
 33 | - [add audio input support via ENABLEINPUT variable in shell script](https://github.com/rasprague/m8c-piboy/commit/a1e340c59833d3ff3dabb633da3b03291e77d7e2)
 34 | - [add m8c-choose.sh, choose your audio interface from a list](https://github.com/rasprague/m8c-piboy/commit/fd04fd6c50caff03a6d7f25e08b1e628ce56b790)
 35 | 
 36 | # Thanks to
 37 | - [laamaa](https://github.com/laamaa) for the [cross-platform m8c client](https://github.com/laamaa/m8c)
 38 | - [DirtyWave](https://github.com/Dirtywave) and Trash80 for the excellent M8 Tracker and [m8 headless firmware](https://github.com/Dirtywave/M8HeadlessFirmware)
 39 | - u/rhinofinger for [this reddit post](https://www.reddit.com/r/RetroPie/comments/lurmu0/pico8_in_retropie_easy_uptodate_tutorial_with/) that clued me in on how to add entries into EmulationStation
 40 | - everyone testing this on their own hardware setups
 41 | 
 42 | # Requirements
 43 | - A working [m8 headless](https://github.com/Dirtywave/M8HeadlessFirmware) setup on a Teensy 4.1
 44 | - A working Raspberry Pi / Retropie setup on one of the following handheld hardware:
 45 |   - PiBoy DMG, see [the PiBoy DMG Getting Started guide](https://resources.experimentalpi.com/the-complete-piboy-dmg-getting-started-guide/)
 46 |   - Waveshare Game HAT, see [the Game HAT Wiki](https://www.waveshare.com/wiki/Game_HAT) and [manual](https://www.waveshare.com/w/upload/2/22/Game_HAT_user_manual_en.pdf)
 47 |   - a plain old Raspberry Pi 3 B+
 48 |   - other systems may work but will need additional support, e.g. you get it working and share your findings with us, or you can send me some hardware so I might get is working =]
 49 | 
 50 | # Installation
 51 | 
 52 | ## building from source
 53 | 
 54 | These instructions are tested with Raspberry Pi 3 B+ and the official RetroPie distribution.
 55 | 
 56 | The instructions assume that you already have a working Retropie installation with an internet connection.
 57 | 
 58 | **Open Terminal or SSH into you Pi and run the following commands:**
 59 | 
 60 | ### Install required packages
 61 | 
 62 | ```
 63 | sudo apt update && sudo apt install -y git gcc make libsdl2-dev
 64 | ```
 65 | 
 66 | ### Build and install libserialport from source
 67 | Required since the libserialport-dev apt package is out of date
 68 | 
 69 | follow the README at https://github.com/sigrokproject/libserialport
 70 | 
 71 | then run
 72 | ```
 73 | sudo ldconfig
 74 | ```
 75 | to ensure the library is found when building m8c
 76 | 
 77 | ### Download source code
 78 | 
 79 | ```
 80 | mkdir ~/code && cd ~/code
 81 | git clone https://github.com/rasprague/m8c-piboy.git
 82 |  ```
 83 | 
 84 | ### Build the program
 85 | 
 86 | ```
 87 | cd m8c-piboy
 88 | make
 89 |  ```
 90 | 
 91 | ### Make shell scripts user executable
 92 | ```
 93 | chmod u+x m8c*.sh
 94 | ```
 95 | 
 96 | ### Start m8c once to generate config files
 97 | ```
 98 | /home/pi/code/m8c-piboy/m8c-nojack.sh
 99 | ```
100 | then Ctrl-C to quit
101 | 
102 | ### Enable built-in controller support
103 | A line to make the PiBoy (and Game Hat) built-in controller visible to SDL has been added to gamecontrollerdb.txt, we just need to point m8c to it.
104 | 
105 | ```
106 | cd ~/.local/share/m8c
107 | rm gamecontrollerdb.txt
108 | ln -s ~/code/m8c-piboy/gamecontrollerdb.txt .
109 | ```
110 | 
111 | ### Optional: swap A and B buttons
112 | in ~/.local/share/m8c/config.ini
113 | 
114 | change
115 | ```
116 | gamepad_opt=1
117 | gamepad_edit=0
118 | ```
119 | to
120 | ```
121 | gamepad_opt=0
122 | gamepad_edit=1
123 | ```
124 | 
125 | ### Optional: fix cursor movement
126 | if your cursor movement is messed up, set these two entries in ~/.local/share/m8c/config.ini
127 | 
128 | ```
129 | gamepad_analog_axis_select=-1
130 | gamepad_analog_axis_start=-1
131 | ```
132 | 
133 | ### Optional: disable mouse cursor
134 | in ~/.local/share/m8c/config.ini
135 | 
136 | under the ```[graphics]``` section, add ```disable_cursor=true```
137 | 
138 | ### Install JACK for audio routing
139 | See AUDIOGUIDE.md for the details
140 | 
141 | ```
142 | sudo apt install jackd2
143 | sudo usermod -a -G audio pi
144 | ```
145 | 
146 | ### Optional: allow JACKD to use realtime scheduling
147 | ```
148 | sudo mv /etc/security/limits.d/audio.conf.disabled /etc/security/limits.d/audio.conf
149 | ```
150 | 
151 | then restart your system
152 | 
153 | ### Try it out!
154 | ```
155 | /home/pi/code/m8c-piboy/m8c.sh
156 | ```
157 | 
158 | # Adding m8c to EmulationStation
159 | 
160 | ### Install m8c 'ROMs'
161 | ```
162 | mkdir -p /home/pi/RetroPie/roms/m8 && cd /home/pi/RetroPie/roms/m8
163 | ln -s /home/pi/code/m8c-piboy/*.sh .
164 | ```
165 | 
166 | ### Add m8 system entry
167 | - go to /home/pi/.emulationstation/
168 | - append the contents of this repo's file es_systems.cfg.m8c.paste.txt to the bottom of es_systems.cfg (just before the ```</systemList>``` line) in that folder (/home/pi/.emulationstation/es_systems.cfg)
169 | 
170 | If you don't already have an es_systems.cfg file in /home/pi/.emulationstation/, first copy the es_systems.cfg file that's in /etc/emulationstation/ into /home/pi/.emulationstation/.
171 | 
172 | - restart EmulationStation
173 | 
174 | This adds "m8" to your EmulationStation game console selection menu.
175 | 
176 | # Using a different audio output device (e.g. external USB sounds card)
177 | 
178 | You have a couple of options
179 | 
180 | ## Choose audio interface at startup
181 | run m8c-choose.sh and choose you audio interface options from the dialogs
182 | 
183 | ## Make a custom startup script
184 | - find your audio device number with ```aplay -l```
185 | ```
186 | pi@retropie:~ $ aplay -l
187 | **** List of PLAYBACK Hardware Devices ****
188 | card 0: Headphones [bcm2835 Headphones], device 0: bcm2835 Headphones [bcm2835 Headphones]
189 |   Subdevices: 8/8
190 |   Subdevice #0: subdevice #0
191 |   Subdevice #1: subdevice #1
192 |   Subdevice #2: subdevice #2
193 |   Subdevice #3: subdevice #3
194 |   Subdevice #4: subdevice #4
195 |   Subdevice #5: subdevice #5
196 |   Subdevice #6: subdevice #6
197 |   Subdevice #7: subdevice #7
198 | card 1: CODEC [USB Audio CODEC], device 0: USB Audio [USB Audio]
199 |   Subdevices: 0/1
200 |   Subdevice #0: subdevice #0
201 | card 2: M8 [M8], device 0: USB Audio [USB Audio]
202 |   Subdevices: 0/1
203 |   Subdevice #0: subdevice #0
204 | ```
205 | here we'll use card 1 as an example
206 | 
207 | - in the m8 roms folder, make a copy of m8c-custom.sh.example, e.g.
208 | ```
209 | cd ~/RetroPie/roms/m8
210 | cp ~/code/m8c-piboy/m8c-custom.sh.example ./m8c-usbaudio.sh
211 | ```
212 | - edit your new .sh file (e.g. m8c-usbaudio.sh), and at the top change e.g. ```HWAUDIODEVICE=0``` to ```HWAUDIODEVICE=1```
213 | - Optioinal: enable audio input (if your audio interface supports it) by changning ```ENABLEINPUT=0``` to ```ENABLEINPUT=1```
214 | - make your new .sh file (e.g. m8c-usbaudio.sh) executable with ```chmod u+x m8c-usbaudio.sh```
215 | - restart EmulationStation
216 | 
217 | ---
218 | # orignal m8c README below
219 | # m8c
220 | 
221 | # Introduction
222 | 
223 | The [Dirtywave M8 Tracker](https://dirtywave.com/products/m8-tracker) is a portable sequencer and synthesizer, featuring 8 tracks of assignable instruments such as FM, waveform synthesis, virtual analog, sample playback, and MIDI output. It is powered by a [Teensy](https://www.pjrc.com/teensy/) micro-controller and inspired by the Gameboy tracker [Little Sound DJ](https://www.littlesounddj.com/lsd/index.php).
224 | 
225 | While Dirtywave makes new batches of units available on a regular basis, M8 is sometimes sold out due to the worldwide chip shortage and high demand of the unit. To fill this gap and and to allow users to freely test this wonderful tracker, [Timothy Lamb](https://github.com/trash80) was kind enough to make the [M8 Headless](https://github.com/Dirtywave/M8HeadlessFirmware) available to everyone.
226 | 
227 | If you like the M8 and you gel with the tracker workflow, please support [Dirtywave](https://dirtywave.com/) by purchasing the actual unit. You can check its availability [here](https://dirtywave.com/products/m8-tracker). Meanwhile, you can also subscribe to Timothy Lamb's [Patreon](https://www.patreon.com/trash80).
228 | 
229 | *m8c* is a client for Dirtywave M8 tracker's headless mode. The application should be cross-platform ready and can be built in Linux, Windows (with MSYS2/MINGW64) and Mac OS.
230 | 
231 | Please note that routing the headless M8 USB audio isn't in the scope of this program -- if this is needed, it can be achieved with tools like Pipewire, Pulseaudio, Jack w/ alsa\_in and alsa\_out just to name a few. The file AUDIOGUIDE.md contains some examples for routing the audio.
232 | 
233 | If you want to route audio with the headless client you could try https://github.com/booss/rm8 which is a great native client with audio support (among other user features)!
234 | 
235 | Many thanks to:
236 | 
237 | * Trash80 for the great M8 hardware and the original font (stealth57.ttf) that was converted to a bitmap for use in the progam.
238 | * driedfruit for a wonderful little routine to blit inline bitmap fonts, https://github.com/driedfruit/SDL_inprint/
239 | * marcinbor85 for the slip handling routine, https://github.com/marcinbor85/slip
240 | * turbolent for the great Golang-based g0m8 application, which I used as reference on how the M8 serial protocol works.
241 | * *Everyone who's contributed to m8c!*
242 | 
243 | Disclaimer: I'm not a coder and hardly understand C, use at your own risk :)
244 | 
245 | -------
246 | 
247 | # Installation
248 | 
249 | ## Windows / MacOS
250 | 
251 | There are prebuilt binaries available in the [releases section](https://github.com/laamaa/m8c/releases/) for Windows and recent versions of MacOS.
252 | 
253 | ## Linux / MacOS (building from source)
254 | 
255 | These instructions are tested with Raspberry Pi 3 B+ and Raspberry Pi OS with desktop (March 4 2021 release), but should apply for other Debian/Ubuntu flavors as well. The begining on the build process on OSX is slightly different at the start, and then the same once packages are installed.
256 | 
257 | The instructions assume that you already have a working Linux desktop installation with an internet connection.
258 | 
259 | Open Terminal and run the following commands:
260 | 
261 | ### Install required packages (Raspberry Pi, Linux)
262 | 
263 | ```
264 | sudo apt update && sudo apt install -y git gcc make libsdl2-dev libserialport-dev
265 | ```
266 | ### Install required packages (OSX)
267 | 
268 | This assumes you have [installed brew](https://docs.brew.sh/Installation)
269 | 
270 | ```
271 | brew update && brew install git gcc make sdl2 libserialport pkg-config
272 | ```
273 | ### Download source code (All)
274 | 
275 | ```
276 | mkdir code && cd code
277 | git clone https://github.com/laamaa/m8c.git
278 |  ```
279 | 
280 | ### Build the program
281 | 
282 | ```
283 | cd m8c
284 | make
285 |  ```
286 | 
287 | ### Start the program
288 | 
289 | Connect the M8 or Teensy (with headless firmware) to your computer and start the program. It should automatically detect your device.
290 | 
291 | ```
292 | ./m8c
293 | ```
294 | 
295 | If the stars are aligned correctly, you should see the M8 screen.
296 | 
297 | -----------
298 | 
299 | ## Keyboard mappings
300 | 
301 | Keys for controlling the progam:
302 | 
303 | * Up arrow = up
304 | * Down arrow = down
305 | * Left arrow = left
306 | * Right arrow = right
307 | * a / left shift = select
308 | * s / space = start
309 | * z / left alt = opt
310 | * x / left ctrl = edit
311 | 
312 | Additional controls:
313 | * Alt + enter = toggle full screen / windowed
314 | * Alt + F4 = quit program
315 | * Delete = opt+edit (deletes a row)
316 | * Esc = toggle keyjazz on/off 
317 | * r / select+start+opt+edit = reset display (if glitches appear on the screen, use this)
318 | 
319 | ### Keyjazz
320 | Keyjazz allows to enter notes with keyboard, oldschool tracker-style. The layout is two octaves, starting from keys Z and Q.
321 | When keyjazz is active, regular a/s/z/x keys are disabled. The base octave can be adjusted with numpad star/divide keys and the velocity can be set 
322 | 
323 | * Numpad asterisk (\*): increase base octave
324 | * Numpad divide (/): decrease base ooctave
325 | * Numpad plus (+): increase velocity
326 | * Numpad minus (-): decrease velocity
327 | 
328 | ## Gamepads
329 | 
330 | The program uses SDL's game controller system, which should make it work automagically with most gamepads. On startup, the program tries to load a SDL game controller database named gamecontrollerdb.txt from the same directory as the config file. If your joypad doesn't work out of the box, you might need to create custom bindings to this file, for example with [SDL2 Gamepad Tool](https://generalarcade.com/gamepadtool/).
331 | 
332 | ## Config
333 | 
334 | Keyboard and game controller bindings can be configured via `config.ini`.
335 | 
336 | If not found, the file will be created in one of these locations:
337 | * Windows: `C:\Users\<username>\AppData\Roaming\m8c\config.ini`
338 | * Linux: `/home/<username>/.local/share/m8c/config.ini`
339 | * MacOS: `/Users/<username>/Library/Application Support/m8c/config.ini`
340 | 
341 | See the `config.ini.sample` file to see the available options.
342 | 
343 | Enjoy making some nice music!
344 | 
345 | -----------
346 | 
347 | ## FAQ
348 | 
349 | * When starting the program, something like the following appears and the program does not start:
350 | ```
351 | $ ./m8c
352 | INFO: Looking for USB serial devices.
353 | INFO: Found M8 in /dev/ttyACM1.
354 | INFO: Opening port.
355 | ERROR: Error: Failed: Permission denied
356 | ```
357 | 
358 | This is likely caused because the user running m8c does not have permission to use the serial port. The eaiest way to fix this is to add the current user to a group with permission to use the serial port.
359 | 
360 | On Linux systems, look at the permissions on the serial port shown on the line that says "Found M8 in":
361 | ```
362 | $ ls -la /dev/ttyACM1
363 | crw-rw---- 1 root dialout 166, 0 Jan  8 14:51 /dev/ttyACM0
364 | ```
365 | 
366 | This shows that the serial port is owned by the user 'root' and the group 'dialout'. Both the user and the group have read/write permissions. To add a user to the group, run this command, replacing 'dialout' with the group shown on your own system:
367 | 
368 |     sudo adduser $USER dialout
369 | 
370 | You may need to log out and back in or even fully reboot the system for this change to take effect, but this will hopefully fix the problem. Please see [this issue for more details](https://github.com/laamaa/m8c/issues/20).
371 | 
372 | -----------
373 | 
374 | ### Bonus content: quickly install m8c locally with nix
375 | 
376 | ``` sh
377 | nix-env -iA m8c-stable -f https://github.com/laamaa/m8c/archive/refs/heads/main.tar.gz
378 | ```
379 | 


--------------------------------------------------------------------------------