Emulation/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-05-20 13:27:22 -04:00
Code Issues Packages Projects Releases Wiki Activity
RetroArch/input/drivers_joypad/test_joypad.c
zoltanvb b27233b3b8
Test input joypad driver (#16370) 
* Test driver for joypad inputs

Add a new joypad input driver:
- hide driver behind #ifdef and enable it in config_params.sh
- add a new config parameter to specify the test input file
- add aux files: additional config files that cancel out any binds
  that may be present in RA config, autoconfig profile for
  test joypads, test input file that matches controller test
  sequence

* Fixes and comments for test input driver.
2024-03-18 12:07:36 -07:00

483 lines
15 KiB
C
Raw Blame History

/* RetroArch - A frontend for libretro.
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2016-2019 - Brad Parker
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
/* Possible improvement list:
* Add vid/pid to autoconf profile step, if autoconf matching needs testing
* Multiple device autoconf profiles, with different analog/digital setup, analog buttons, extra buttons, unconfigured buttons...
* Unimplemented functions (get_button, rumble)
*/
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <libretro.h>
#include <file/file_path.h>
#include <string/stdstring.h>
#include <streams/file_stream.h>
#include <formats/rjson.h>
#include "../../config.def.h"
#include "../../verbosity.h"
#include "../input_driver.h"
#include "../../tasks/tasks_internal.h"
#include "../../gfx/video_driver.h"
#define MAX_TEST_STEPS 200
#define NUM_BUTTONS 32
#ifndef MAX_AXIS
#define MAX_AXIS 10
#endif
#define JOYPAD_TEST_COMMAND_ADD_CONTROLLER 1
#define JOYPAD_TEST_COMMAND_BUTTON_PRESS_FIRST 16
#define JOYPAD_TEST_COMMAND_BUTTON_PRESS_LAST 31
#define JOYPAD_TEST_COMMAND_BUTTON_RELEASE_FIRST 32
#define JOYPAD_TEST_COMMAND_BUTTON_RELEASE_LAST 47
#define JOYPAD_TEST_COMMAND_BUTTON_AXIS_FIRST 1000
#define JOYPAD_TEST_COMMAND_BUTTON_AXIS_LAST JOYPAD_TEST_COMMAND_BUTTON_AXIS_FIRST+MAX_AXIS*DEFAULT_MAX_PADS
typedef struct
{
char* name;
uint32_t button_state;
int32_t axis_state[MAX_AXIS];
} test_joypad_data;
static test_joypad_data test_joypads[MAX_USERS];
typedef struct
{
unsigned frame;
unsigned action;
unsigned param_num;
char param_str[255];
bool handled;
} input_test_step_t;
static input_test_step_t input_test_steps[MAX_TEST_STEPS];
static unsigned current_frame = 0;
static unsigned next_teststep_frame = 0;
static unsigned current_test_step = 0;
static unsigned last_test_step = MAX_TEST_STEPS + 1;
static uint32_t input_state_validated = 0;
static uint32_t combo_state_validated = 0;
static bool dump_state_blocked = false;
/************************************/
/* JSON Helpers for test input file */
/************************************/
typedef struct
{
unsigned *current_entry_uint_val;
char **current_entry_str_val;
unsigned frame;
unsigned action;
unsigned param_num;
char *param_str;
} JTifJSONContext;
static bool JTifJSONObjectEndHandler(void* context)
{
JTifJSONContext *pCtx = (JTifJSONContext*)context;
/* Too long input is handled elsewhere, it should not lead to parse error */
if (current_test_step >= MAX_TEST_STEPS)
return true;
/* Copy values read from JSON file + fill defaults */
if (pCtx->frame == 0xffff)
input_test_steps[current_test_step].frame = input_test_steps[current_test_step-1].frame + 60;
else
input_test_steps[current_test_step].frame = pCtx->frame;
input_test_steps[current_test_step].action = pCtx->action;
input_test_steps[current_test_step].param_num = pCtx->param_num;
input_test_steps[current_test_step].handled = false;
if (!string_is_empty(pCtx->param_str))
strlcpy(
input_test_steps[current_test_step].param_str, pCtx->param_str,
sizeof(input_test_steps[current_test_step].param_str));
else
input_test_steps[current_test_step].param_str[0] = '\0';
current_test_step++;
last_test_step = current_test_step;
pCtx->frame = 0xffff;
return true;
}
static bool JTifJSONObjectMemberHandler(void* context, const char *pValue, size_t length)
{
JTifJSONContext *pCtx = (JTifJSONContext*)context;
/* something went wrong */
if (pCtx->current_entry_str_val)
return false;
if (length)
{
if (string_is_equal(pValue, "frame"))
pCtx->current_entry_uint_val = &pCtx->frame;
else if (string_is_equal(pValue, "action"))
pCtx->current_entry_uint_val = &pCtx->action;
else if (string_is_equal(pValue, "param_num"))
pCtx->current_entry_uint_val = &pCtx->param_num;
else if (string_is_equal(pValue, "param_str"))
pCtx->current_entry_str_val = &pCtx->param_str;
/* ignore unknown members */
}
return true;
}
static bool JTifJSONNumberHandler(void* context, const char *pValue, size_t length)
{
JTifJSONContext *pCtx = (JTifJSONContext*)context;
if (pCtx->current_entry_uint_val && length && !string_is_empty(pValue))
*pCtx->current_entry_uint_val = string_to_unsigned(pValue);
/* ignore unknown members */
pCtx->current_entry_uint_val = NULL;
return true;
}
static bool JTifJSONStringHandler(void* context, const char *pValue, size_t length)
{
JTifJSONContext *pCtx = (JTifJSONContext*)context;
if (pCtx->current_entry_str_val && length && !string_is_empty(pValue))
{
if (*pCtx->current_entry_str_val)
free(*pCtx->current_entry_str_val);
*pCtx->current_entry_str_val = strdup(pValue);
}
/* ignore unknown members */
pCtx->current_entry_str_val = NULL;
return true;
}
/* Parses test input file referenced by file_path.
* Does nothing if test input file does not exist. */
static bool input_test_file_read(const char* file_path)
{
bool success = false;
JTifJSONContext context = {0};
RFILE *file = NULL;
rjson_t* parser;
/* Sanity check */
if ( string_is_empty(file_path)
|| !path_is_valid(file_path)
)
{
RARCH_DBG("[Test input driver]: No test input file supplied.\n");
return false;
}
/* Attempt to open test input file */
file = filestream_open(
file_path,
RETRO_VFS_FILE_ACCESS_READ,
RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
{
RARCH_ERR("[Test input driver]: Failed to open test input file: \"%s\".\n",
file_path);
return false;
}
/* Initialise JSON parser */
if (!(parser = rjson_open_rfile(file)))
{
RARCH_ERR("[Test input driver]: Failed to create JSON parser.\n");
goto end;
}
/* Configure parser */
rjson_set_options(parser, RJSON_OPTION_ALLOW_UTF8BOM);
/* Read file */
if (rjson_parse(parser, &context,
JTifJSONObjectMemberHandler,
JTifJSONStringHandler,
JTifJSONNumberHandler,
NULL, JTifJSONObjectEndHandler, NULL, NULL, /* object/array handlers */
NULL, NULL) /* unused boolean/null handlers */
!= RJSON_DONE)
{
if (rjson_get_source_context_len(parser))
{
RARCH_ERR(
"[Test input driver]: Error parsing chunk of test input file: %s\n---snip---\n%.*s\n---snip---\n",
file_path,
rjson_get_source_context_len(parser),
rjson_get_source_context_buf(parser));
}
RARCH_WARN(
"[Test input driver]: Error parsing test input file: %s\n",
file_path);
RARCH_ERR(
"[Test input driver]: Error: Invalid JSON at line %d, column %d - %s.\n",
(int)rjson_get_source_line(parser),
(int)rjson_get_source_column(parser),
(*rjson_get_error(parser) ? rjson_get_error(parser) : "format error"));
}
/* Free parser */
rjson_free(parser);
success = true;
end:
/* Clean up leftover strings */
if (context.param_str)
free(context.param_str);
/* Close log file */
filestream_close(file);
if (last_test_step >= MAX_TEST_STEPS)
{
RARCH_WARN("[Test input driver]: too long test input json, maximum size: %d\n",MAX_TEST_STEPS);
}
for (current_test_step = 0; current_test_step < last_test_step; current_test_step++)
{
RARCH_DBG(
"[Test input driver]: test step %02d read from file: frame %d, action %x, num %x, str %s\n",
current_test_step,
input_test_steps[current_test_step].frame,
input_test_steps[current_test_step].action,
input_test_steps[current_test_step].param_num,
input_test_steps[current_test_step].param_str);
}
current_test_step = 0;
return success;
}
/********************************/
/* Test input file handling end */
/********************************/
static const char *test_joypad_name(unsigned pad)
{
if (pad >= MAX_USERS || string_is_empty(test_joypads[pad].name))
return NULL;
return test_joypads[pad].name;
}
static void test_joypad_autodetect_add(unsigned autoconf_pad)
{
input_autoconfigure_connect(
test_joypad_name(autoconf_pad),
NULL,
"test",
autoconf_pad,
0,
0
);
}
static void *test_joypad_init(void *data)
{
settings_t *settings = config_get_ptr();
unsigned i;
input_test_file_read(settings->paths.test_input_file_joypad);
if (last_test_step > MAX_TEST_STEPS)
last_test_step = 0;
for(i=0; i<last_test_step; i++)
{
if (input_test_steps[i].frame > 0)
continue;
if (input_test_steps[i].action == JOYPAD_TEST_COMMAND_ADD_CONTROLLER)
{
test_joypads[input_test_steps[i].param_num].name = input_test_steps[i].param_str;
test_joypad_autodetect_add(input_test_steps[i].param_num);
input_test_steps[i].handled = true;
}
}
return (void*)-1;
}
static int32_t test_joypad_button(unsigned port_num, uint16_t joykey)
{
int16_t ret = 0;
if (port_num >= DEFAULT_MAX_PADS)
return 0;
if (joykey < NUM_BUTTONS)
return (BIT32_GET(test_joypads[port_num].button_state, joykey));
return 0;
}
static int16_t test_joypad_axis(unsigned port_num, uint32_t joyaxis)
{
/*RARCH_DBG("test_joypad_axis %d / %u\n",port_num, joyaxis);*/
if (port_num >= DEFAULT_MAX_PADS)
return 0;
if (AXIS_NEG_GET(joyaxis) < MAX_AXIS)
{
/* Kernel returns values in range [-0x7fff, 0x7fff]. */
int16_t val = test_joypads[port_num].axis_state[AXIS_NEG_GET(joyaxis)];
if (val < 0)
return val;
}
else if (AXIS_POS_GET(joyaxis) < MAX_AXIS)
{
int16_t val = test_joypads[port_num].axis_state[AXIS_POS_GET(joyaxis)];
if (val > 0)
return val;
}
return 0;
}
static int16_t test_joypad_state(
rarch_joypad_info_t *joypad_info,
const struct retro_keybind *binds,
unsigned port)
{
unsigned i;
int16_t ret = 0;
uint16_t port_idx = joypad_info->joy_idx;
if (port_idx < DEFAULT_MAX_PADS)
{
for (i = 0; i < RARCH_FIRST_CUSTOM_BIND; i++)
{
/* Auto-binds are per joypad, not per user. */
const uint16_t joykey = (binds[i].joykey != NO_BTN)
? binds[i].joykey : joypad_info->auto_binds[i].joykey;
/* Test input driver uses same button layout internally as RA, so no conversion is needed */
if (joykey != NO_BTN && (test_joypads[port_idx].button_state & (1 << i)))
{
ret |= ( 1 << i);
}
}
}
return ret;
}
static void test_joypad_poll(void)
{
video_driver_state_t *video_st = video_state_get_ptr();
uint64_t curr_frame = video_st->frame_count;
unsigned i;
for (i=0; i<last_test_step; i++)
{
if (!input_test_steps[i].handled && curr_frame > input_test_steps[i].frame)
{
if (input_test_steps[i].action == JOYPAD_TEST_COMMAND_ADD_CONTROLLER)
{
test_joypads[input_test_steps[i].param_num].name = input_test_steps[i].param_str;
test_joypad_autodetect_add(input_test_steps[i].param_num);
input_test_steps[i].handled = true;
}
else if( input_test_steps[i].action >= JOYPAD_TEST_COMMAND_BUTTON_PRESS_FIRST &&
input_test_steps[i].action <= JOYPAD_TEST_COMMAND_BUTTON_PRESS_LAST)
{
unsigned targetpad = input_test_steps[i].action - JOYPAD_TEST_COMMAND_BUTTON_PRESS_FIRST;
test_joypads[targetpad].button_state |= input_test_steps[i].param_num;
input_test_steps[i].handled = true;
RARCH_DBG(
"[Test input driver]: Pressing device %d buttons %x, new state %x.\n",
targetpad,input_test_steps[i].param_num,test_joypads[targetpad].button_state);
}
else if( input_test_steps[i].action >= JOYPAD_TEST_COMMAND_BUTTON_RELEASE_FIRST &&
input_test_steps[i].action <= JOYPAD_TEST_COMMAND_BUTTON_RELEASE_LAST)
{
unsigned targetpad = input_test_steps[i].action - JOYPAD_TEST_COMMAND_BUTTON_RELEASE_FIRST;
test_joypads[targetpad].button_state &= ~input_test_steps[i].param_num;
input_test_steps[i].handled = true;
RARCH_DBG(
"[Test input driver]: Releasing device %d buttons %x, new state %x.\n",
targetpad,input_test_steps[i].param_num,test_joypads[targetpad].button_state);
}
else if( input_test_steps[i].action >= JOYPAD_TEST_COMMAND_BUTTON_AXIS_FIRST &&
input_test_steps[i].action <= JOYPAD_TEST_COMMAND_BUTTON_AXIS_LAST)
{
unsigned targetpad =
(input_test_steps[i].action - JOYPAD_TEST_COMMAND_BUTTON_AXIS_FIRST) / MAX_AXIS;
unsigned targetaxis =
input_test_steps[i].action - JOYPAD_TEST_COMMAND_BUTTON_AXIS_FIRST - (targetpad*MAX_AXIS);
if (targetpad < DEFAULT_MAX_PADS && targetaxis < MAX_AXIS)
test_joypads[targetpad].axis_state[targetaxis] = (int16_t) input_test_steps[i].param_num;
else
RARCH_WARN(
"[Test input driver]: Decoded axis outside target range: action %d pad %d axis %d.\n",
input_test_steps[i].action, targetpad, targetaxis);
input_test_steps[i].handled = true;
RARCH_DBG(
"[Test input driver]: Setting axis device %d axis %d value %d.\n",
targetpad, targetaxis, (int16_t)input_test_steps[i].param_num);
}
else
{
input_test_steps[i].handled = true;
RARCH_WARN(
"[Test input driver]: Unrecognized action %d in step %d, skipping\n",
input_test_steps[i].action,i);
}
}
}
}
static bool test_joypad_query_pad(unsigned pad)
{
return (pad < MAX_USERS);
}
static void test_joypad_destroy(void)
{
}
input_device_driver_t test_joypad = {
test_joypad_init,
test_joypad_query_pad,
test_joypad_destroy,
test_joypad_button,
test_joypad_state,
NULL, /* get_buttons */
test_joypad_axis,
test_joypad_poll,
NULL, /* rumble */
NULL, /* rumble_gain */
test_joypad_name,
"test",
};
Reference in a new issue View git blame Copy permalink