mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-18 13:20:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Split up midi_driver code to midi_driver.c

Browse Source
This commit is contained in:
twinaphex 2021-09-20 03:43:37 +02:00
parent 5eb795bf5b
commit 238eb649a2
8 changed files with 651 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.common
View File

@ -236,6 +236,7 @@ OBJ += frontend/frontend_driver.o \
retroarch.o \
command.o \
msg_hash.o \
midi_driver.o \
intl/msg_hash_us.o \
$(LIBRETRO_COMM_DIR)/queues/task_queue.o \
tasks/task_content.o

1
griffin/griffin.c
View File

@ -1214,6 +1214,7 @@ RETROARCH
============================================================ */
#include "../retroarch.c"
#include "../command.c"
#include "../midi_driver.c"
#include "../libretro-common/queues/task_queue.c"
#include "../msg_hash.c"

5
menu/menu_setting.c
View File

@ -81,7 +81,7 @@
#include "../list_special.h"
#include "../bluetooth/bluetooth_driver.h"
#include "../wifi/wifi_driver.h"
#include "../midi/midi_driver.h"
#include "../midi_driver.h"
#include "../tasks/tasks_internal.h"
#include "../config.def.h"
#include "../ui/ui_companion_driver.h"
@ -7952,7 +7952,8 @@ static void general_write_handler(rarch_setting_t *setting)
case MENU_ENUM_LABEL_MIDI_OUTPUT:
{
settings_t *settings = config_get_ptr();
midi_driver_set_output(settings->arrays.midi_output);
midi_driver_set_output(settings,
settings->arrays.midi_output);
}
break;
case MENU_ENUM_LABEL_MIDI_VOLUME:

618
midi_driver.c Normal file
View File

@ -0,0 +1,618 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2021 - Daniel De Matteis
*
* 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/>.
*/
#include <boolean.h>
#include <lists/string_list.h>
#include <string/stdstring.h>
#include "configuration.h"
#include "midi_driver.h"
#include "verbosity.h"
#define MIDI_DRIVER_BUF_SIZE 4096
static void *rarch_midi_drv_data;
static struct string_list *rarch_midi_drv_inputs;
static struct string_list *rarch_midi_drv_outputs;
static uint8_t *rarch_midi_drv_input_buffer;
static uint8_t *rarch_midi_drv_output_buffer;
static midi_event_t rarch_midi_drv_input_event; /* ptr alignment */
static midi_event_t rarch_midi_drv_output_event; /* ptr alignment */
static bool rarch_midi_drv_input_enabled;
static bool rarch_midi_drv_output_enabled;
static bool rarch_midi_drv_output_pending;
static void null_midi_free(void *p) { }
static void *null_midi_init(const char *input, const char *output) { return (void*)-1; }
static bool null_midi_get_avail_inputs(struct string_list *inputs) { union string_list_elem_attr attr = {0}; return string_list_append(inputs, "Null", attr); }
static bool null_midi_get_avail_outputs(struct string_list *outputs) { union string_list_elem_attr attr = {0}; return string_list_append(outputs, "Null", attr); }
static bool null_midi_set_input(void *p, const char *input) { return input == NULL || string_is_equal(input, "Null"); }
static bool null_midi_set_output(void *p, const char *output) { return output == NULL || string_is_equal(output, "Null"); }
static bool null_midi_read(void *p, midi_event_t *event) { return false; }
static bool null_midi_write(void *p, const midi_event_t *event) { return true; }
static bool null_midi_flush(void *p) { return true; }
static midi_driver_t midi_null = {
"null",
null_midi_get_avail_inputs,
null_midi_get_avail_outputs,
null_midi_init,
null_midi_free,
null_midi_set_input,
null_midi_set_output,
null_midi_read,
null_midi_write,
null_midi_flush
};
static midi_driver_t *midi_drv = &midi_null;
midi_driver_t *midi_drivers[] = {
#if defined(HAVE_ALSA) && !defined(HAVE_HAKCHI) && !defined(HAVE_SEGAM) && !defined(DINGUX)
&midi_alsa,
#endif
#ifdef HAVE_WINMM
&midi_winmm,
#endif
&midi_null
};
static midi_driver_t *midi_driver_find_driver(const char *ident)
{
unsigned i;
for (i = 0; i < ARRAY_SIZE(midi_drivers); ++i)
{
if (string_is_equal(midi_drivers[i]->ident, ident))
return midi_drivers[i];
}
RARCH_ERR("[MIDI]: Unknown driver \"%s\", falling back to \"null\" driver.\n", ident);
return &midi_null;
}
const void *midi_driver_find_handle(int index)
{
if (index < 0 || index >= ARRAY_SIZE(midi_drivers))
return NULL;
return midi_drivers[index];
}
struct string_list *midi_driver_get_avail_inputs(void)
{
return rarch_midi_drv_inputs;
}
struct string_list *midi_driver_get_avail_outputs(void)
{
return rarch_midi_drv_outputs;
}
bool midi_driver_set_all_sounds_off(void)
{
midi_event_t event;
uint8_t i;
uint8_t data[3] = { 0xB0, 120, 0 };
bool result = true;
if (!rarch_midi_drv_data || !rarch_midi_drv_output_enabled)
return false;
event.data = data;
event.data_size = sizeof(data);
event.delta_time = 0;
for (i = 0; i < 16; ++i)
{
data[0] = 0xB0 | i;
if (!midi_drv->write(rarch_midi_drv_data, &event))
result = false;
}
if (!midi_drv->flush(rarch_midi_drv_data))
result = false;
if (!result)
RARCH_ERR("[MIDI]: All sounds off failed.\n");
return result;
}
bool midi_driver_set_volume(unsigned volume)
{
midi_event_t event;
uint8_t data[8] = {
0xF0, 0x7F, 0x7F, 0x04, 0x01, 0, 0, 0xF7};
if (!rarch_midi_drv_data || !rarch_midi_drv_output_enabled)
return false;
volume = (unsigned)(163.83 * volume + 0.5);
if (volume > 16383)
volume = 16383;
data[5] = (uint8_t)(volume & 0x7F);
data[6] = (uint8_t)(volume >> 7);
event.data = data;
event.data_size = sizeof(data);
event.delta_time = 0;
if (!midi_drv->write(rarch_midi_drv_data, &event))
{
RARCH_ERR("[MIDI]: Volume change failed.\n");
return false;
}
return true;
}
static bool midi_driver_init_io_buffers(void)
{
uint8_t *midi_drv_input_buffer = (uint8_t*)malloc(MIDI_DRIVER_BUF_SIZE);
uint8_t *midi_drv_output_buffer = (uint8_t*)malloc(MIDI_DRIVER_BUF_SIZE);
if (!midi_drv_input_buffer || !midi_drv_output_buffer)
{
if (midi_drv_input_buffer)
free(midi_drv_input_buffer);
if (midi_drv_output_buffer)
free(midi_drv_output_buffer);
return false;
}
rarch_midi_drv_input_buffer = midi_drv_input_buffer;
rarch_midi_drv_output_buffer = midi_drv_output_buffer;
rarch_midi_drv_input_event.data = midi_drv_input_buffer;
rarch_midi_drv_input_event.data_size = 0;
rarch_midi_drv_output_event.data = midi_drv_output_buffer;
rarch_midi_drv_output_event.data_size = 0;
return true;
}
void midi_driver_free(void)
{
if (rarch_midi_drv_data)
{
midi_drv->free(rarch_midi_drv_data);
rarch_midi_drv_data = NULL;
}
if (rarch_midi_drv_inputs)
{
string_list_free(rarch_midi_drv_inputs);
rarch_midi_drv_inputs = NULL;
}
if (rarch_midi_drv_outputs)
{
string_list_free(rarch_midi_drv_outputs);
rarch_midi_drv_outputs = NULL;
}
if (rarch_midi_drv_input_buffer)
{
free(rarch_midi_drv_input_buffer);
rarch_midi_drv_input_buffer = NULL;
}
if (rarch_midi_drv_output_buffer)
{
free(rarch_midi_drv_output_buffer);
rarch_midi_drv_output_buffer = NULL;
}
rarch_midi_drv_input_enabled = false;
rarch_midi_drv_output_enabled = false;
}
bool midi_driver_init(void *data)
{
union string_list_elem_attr
attr = {0};
bool ret = true;
settings_t *settings = (settings_t*)data;
rarch_midi_drv_inputs = string_list_new();
rarch_midi_drv_outputs = string_list_new();
if (!rarch_midi_drv_inputs || !rarch_midi_drv_outputs)
ret = false;
else if (!string_list_append(rarch_midi_drv_inputs, "Off", attr) ||
!string_list_append(rarch_midi_drv_outputs, "Off", attr))
ret = false;
else
{
char * input = NULL;
char * output = NULL;
midi_drv = midi_driver_find_driver(
settings->arrays.midi_driver);
if (strcmp(midi_drv->ident, settings->arrays.midi_driver))
{
configuration_set_string(settings,
settings->arrays.midi_driver, midi_drv->ident);
}
if (!midi_drv->get_avail_inputs(rarch_midi_drv_inputs))
ret = false;
else if (!midi_drv->get_avail_outputs(rarch_midi_drv_outputs))
ret = false;
else
{
if (string_is_not_equal(settings->arrays.midi_input, "Off"))
{
if (string_list_find_elem(rarch_midi_drv_inputs, settings->arrays.midi_input))
input = settings->arrays.midi_input;
else
{
RARCH_WARN("[MIDI]: Input device \"%s\" unavailable.\n",
settings->arrays.midi_input);
configuration_set_string(settings,
settings->arrays.midi_input, "Off");
}
}
if (string_is_not_equal(settings->arrays.midi_output, "Off"))
{
if (string_list_find_elem(rarch_midi_drv_outputs, settings->arrays.midi_output))
output = settings->arrays.midi_output;
else
{
RARCH_WARN("[MIDI]: Output device \"%s\" unavailable.\n",
settings->arrays.midi_output);
configuration_set_string(settings,
settings->arrays.midi_output, "Off");
}
}
rarch_midi_drv_data = midi_drv->init(input, output);
if (!rarch_midi_drv_data)
ret = false;
else
{
rarch_midi_drv_input_enabled = (input != NULL);
rarch_midi_drv_output_enabled = (output != NULL);
if (!midi_driver_init_io_buffers())
ret = false;
else
{
if (input)
RARCH_LOG("[MIDI]: Input device \"%s\".\n", input);
if (output)
{
RARCH_LOG("[MIDI]: Output device \"%s\".\n", output);
midi_driver_set_volume(settings->uints.midi_volume);
}
}
}
}
}
if (!ret)
{
midi_driver_free();
RARCH_ERR("[MIDI]: Initialization failed.\n");
return false;
}
return true;
}
bool midi_driver_set_input(const char *input)
{
if (!rarch_midi_drv_data)
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: midi_driver_set_input called on uninitialized driver.\n");
#endif
return false;
}
if (string_is_equal(input, "Off"))
input = NULL;
if (!midi_drv->set_input(rarch_midi_drv_data, input))
{
if (input)
RARCH_ERR("[MIDI]: Failed to change input device to \"%s\".\n", input);
else
RARCH_ERR("[MIDI]: Failed to disable input.\n");
return false;
}
if (input)
RARCH_LOG("[MIDI]: Input device changed to \"%s\".\n", input);
else
RARCH_LOG("[MIDI]: Input disabled.\n");
rarch_midi_drv_input_enabled = input != NULL;
return true;
}
bool midi_driver_set_output(void *settings_data, const char *output)
{
settings_t *settings = (settings_t*)settings_data;
if (!rarch_midi_drv_data)
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: midi_driver_set_output called on uninitialized driver.\n");
#endif
return false;
}
if (string_is_equal(output, "Off"))
output = NULL;
if (!midi_drv->set_output(rarch_midi_drv_data, output))
{
if (output)
RARCH_ERR("[MIDI]: Failed to change output device to \"%s\".\n", output);
else
RARCH_ERR("[MIDI]: Failed to disable output.\n");
return false;
}
if (output)
{
rarch_midi_drv_output_enabled = true;
RARCH_LOG("[MIDI]: Output device changed to \"%s\".\n", output);
midi_driver_set_volume(settings->uints.midi_volume);
}
else
{
rarch_midi_drv_output_enabled = false;
RARCH_LOG("[MIDI]: Output disabled.\n");
}
return true;
}
bool midi_driver_input_enabled(void)
{
return rarch_midi_drv_input_enabled;
}
bool midi_driver_output_enabled(void)
{
return rarch_midi_drv_output_enabled;
}
bool midi_driver_read(uint8_t *byte)
{
static int i;
if (!rarch_midi_drv_data || !rarch_midi_drv_input_enabled || !byte)
{
#ifdef DEBUG
if (!rarch_midi_drv_data)
RARCH_ERR("[MIDI]: midi_driver_read called on uninitialized driver.\n");
else if (!rarch_midi_drv_input_enabled)
RARCH_ERR("[MIDI]: midi_driver_read called when input is disabled.\n");
else
RARCH_ERR("[MIDI]: midi_driver_read called with null pointer.\n");
#endif
return false;
}
if (i == rarch_midi_drv_input_event.data_size)
{
rarch_midi_drv_input_event.data_size = MIDI_DRIVER_BUF_SIZE;
if (!midi_drv->read(rarch_midi_drv_data,
&rarch_midi_drv_input_event))
{
rarch_midi_drv_input_event.data_size = i;
return false;
}
i = 0;
#ifdef DEBUG
if (rarch_midi_drv_input_event.data_size == 1)
RARCH_LOG("[MIDI]: In [0x%02X].\n",
rarch_midi_drv_input_event.data[0]);
else if (rarch_midi_drv_input_event.data_size == 2)
RARCH_LOG("[MIDI]: In [0x%02X, 0x%02X].\n",
rarch_midi_drv_input_event.data[0],
rarch_midi_drv_input_event.data[1]);
else if (rarch_midi_drv_input_event.data_size == 3)
RARCH_LOG("[MIDI]: In [0x%02X, 0x%02X, 0x%02X].\n",
rarch_midi_drv_input_event.data[0],
rarch_midi_drv_input_event.data[1],
rarch_midi_drv_input_event.data[2]);
else
RARCH_LOG("[MIDI]: In [0x%02X, ...], size %u.\n",
rarch_midi_drv_input_event.data[0],
rarch_midi_drv_input_event.data_size);
#endif
}
*byte = rarch_midi_drv_input_event.data[i++];
return true;
}
bool midi_driver_write(uint8_t byte, uint32_t delta_time)
{
static int event_size;
if (!rarch_midi_drv_data || !rarch_midi_drv_output_enabled)
{
#ifdef DEBUG
if (!rarch_midi_drv_data)
RARCH_ERR("[MIDI]: midi_driver_write called on uninitialized driver.\n");
else
RARCH_ERR("[MIDI]: midi_driver_write called when output is disabled.\n");
#endif
return false;
}
if (byte >= 0x80)
{
if ( rarch_midi_drv_output_event.data_size &&
rarch_midi_drv_output_event.data[0] == 0xF0)
{
if (byte == 0xF7)
event_size = (int)rarch_midi_drv_output_event.data_size + 1;
else
{
if (!midi_drv->write(rarch_midi_drv_data,
&rarch_midi_drv_output_event))
return false;
#ifdef DEBUG
switch (rarch_midi_drv_output_event.data_size)
{
case 1:
RARCH_LOG("[MIDI]: Out [0x%02X].\n",
rarch_midi_drv_output_event.data[0]);
break;
case 2:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X].\n",
rarch_midi_drv_output_event.data[0],
rarch_midi_drv_output_event.data[1]);
break;
case 3:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X, 0x%02X].\n",
rarch_midi_drv_output_event.data[0],
rarch_midi_drv_output_event.data[1],
rarch_midi_drv_output_event.data[2]);
break;
default:
RARCH_LOG("[MIDI]: Out [0x%02X, ...], size %u.\n",
rarch_midi_drv_output_event.data[0],
rarch_midi_drv_output_event.data_size);
break;
}
#endif
rarch_midi_drv_output_pending = true;
event_size = (int)midi_driver_get_event_size(byte);
rarch_midi_drv_output_event.data_size = 0;
rarch_midi_drv_output_event.delta_time = 0;
}
}
else
{
event_size = (int)midi_driver_get_event_size(byte);
rarch_midi_drv_output_event.data_size = 0;
rarch_midi_drv_output_event.delta_time = 0;
}
}
if (rarch_midi_drv_output_event.data_size < MIDI_DRIVER_BUF_SIZE)
{
rarch_midi_drv_output_event.data[rarch_midi_drv_output_event.data_size] = byte;
++rarch_midi_drv_output_event.data_size;
rarch_midi_drv_output_event.delta_time += delta_time;
}
else
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: Output event dropped.\n");
#endif
return false;
}
if (rarch_midi_drv_output_event.data_size == event_size)
{
if (!midi_drv->write(rarch_midi_drv_data,
&rarch_midi_drv_output_event))
return false;
#ifdef DEBUG
switch (rarch_midi_drv_output_event.data_size)
{
case 1:
RARCH_LOG("[MIDI]: Out [0x%02X].\n",
rarch_midi_drv_output_event.data[0]);
break;
case 2:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X].\n",
rarch_midi_drv_output_event.data[0],
rarch_midi_drv_output_event.data[1]);
break;
case 3:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X, 0x%02X].\n",
rarch_midi_drv_output_event.data[0],
rarch_midi_drv_output_event.data[1],
rarch_midi_drv_output_event.data[2]);
break;
default:
RARCH_LOG("[MIDI]: Out [0x%02X, ...], size %u.\n",
rarch_midi_drv_output_event.data[0],
rarch_midi_drv_output_event.data_size);
break;
}
#endif
rarch_midi_drv_output_pending = true;
rarch_midi_drv_output_event.data_size = 0;
rarch_midi_drv_output_event.delta_time = 0;
}
return true;
}
bool midi_driver_flush(void)
{
if (!rarch_midi_drv_data)
return false;
if (rarch_midi_drv_output_pending)
rarch_midi_drv_output_pending =
!midi_drv->flush(rarch_midi_drv_data);
return !rarch_midi_drv_output_pending;
}
size_t midi_driver_get_event_size(uint8_t status)
{
static const uint8_t midi_drv_ev_sizes[128] =
{
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
0, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
if (status < 0x80)
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: midi_driver_get_event_size called with invalid status.\n");
#endif
return 0;
}
return midi_drv_ev_sizes[status - 0x80];
}

25
midi/midi_driver.h → midi_driver.h
View File

@ -207,7 +207,7 @@ struct string_list *midi_driver_get_avail_outputs(void);
bool midi_driver_set_volume(unsigned volume);
bool midi_driver_set_input(const char *input);
bool midi_driver_set_output(const char *output);
bool midi_driver_set_output(void *data, const char *output);
/**
* midi_driver_get_event_size:
@ -222,6 +222,29 @@ bool midi_driver_set_output(const char *output);
**/
size_t midi_driver_get_event_size(uint8_t status);
bool midi_driver_input_enabled(void);
bool midi_driver_output_enabled(void);
bool midi_driver_flush(void);
bool midi_driver_read(uint8_t *byte);
bool midi_driver_write(uint8_t byte, uint32_t delta_time);
bool midi_driver_init(void *data);
void midi_driver_free(void);
bool midi_driver_set_all_sounds_off(void);
const void *midi_driver_find_handle(int index);
extern midi_driver_t midi_winmm;
extern midi_driver_t midi_alsa;
extern midi_driver_t *midi_drivers[];
RETRO_END_DECLS
#endif

569
retroarch.c
View File

@ -236,7 +236,7 @@
#include "wifi/wifi_driver.h"
#include "misc/cpufreq/cpufreq.h"
#include "led/led_driver.h"
#include "midi/midi_driver.h"
#include "midi_driver.h"
#include "core.h"
#include "configuration.h"
#include "list_special.h"
@ -10126,7 +10126,7 @@ bool command_event(enum event_command cmd, void *data)
#endif
break;
case CMD_EVENT_AUDIO_STOP:
midi_driver_set_all_sounds_off(p_rarch);
midi_driver_set_all_sounds_off();
if (!audio_driver_stop(p_rarch))
return false;
break;
@ -20466,567 +20466,6 @@ void config_read_keybinds_conf(void *data)
}
}
/* MIDI */
static midi_driver_t *midi_driver_find_driver(const char *ident)
{
unsigned i;
for (i = 0; i < ARRAY_SIZE(midi_drivers); ++i)
{
if (string_is_equal(midi_drivers[i]->ident, ident))
return midi_drivers[i];
}
RARCH_ERR("[MIDI]: Unknown driver \"%s\", falling back to \"null\" driver.\n", ident);
return &midi_null;
}
static const void *midi_driver_find_handle(int index)
{
if (index < 0 || index >= ARRAY_SIZE(midi_drivers))
return NULL;
return midi_drivers[index];
}
struct string_list *midi_driver_get_avail_inputs(void)
{
struct rarch_state *p_rarch = &rarch_st;
return p_rarch->midi_drv_inputs;
}
struct string_list *midi_driver_get_avail_outputs(void)
{
struct rarch_state *p_rarch = &rarch_st;
return p_rarch->midi_drv_outputs;
}
static bool midi_driver_set_all_sounds_off(struct rarch_state *p_rarch)
{
midi_event_t event;
uint8_t i;
uint8_t data[3] = { 0xB0, 120, 0 };
bool result = true;
if (!p_rarch->midi_drv_data || !p_rarch->midi_drv_output_enabled)
return false;
event.data = data;
event.data_size = sizeof(data);
event.delta_time = 0;
for (i = 0; i < 16; ++i)
{
data[0] = 0xB0 | i;
if (!midi_drv->write(p_rarch->midi_drv_data, &event))
result = false;
}
if (!midi_drv->flush(p_rarch->midi_drv_data))
result = false;
if (!result)
RARCH_ERR("[MIDI]: All sounds off failed.\n");
return result;
}
bool midi_driver_set_volume(unsigned volume)
{
midi_event_t event;
struct rarch_state *p_rarch = &rarch_st;
uint8_t data[8] = {
0xF0, 0x7F, 0x7F, 0x04, 0x01, 0, 0, 0xF7};
if (!p_rarch->midi_drv_data || !p_rarch->midi_drv_output_enabled)
return false;
volume = (unsigned)(163.83 * volume + 0.5);
if (volume > 16383)
volume = 16383;
data[5] = (uint8_t)(volume & 0x7F);
data[6] = (uint8_t)(volume >> 7);
event.data = data;
event.data_size = sizeof(data);
event.delta_time = 0;
if (!midi_drv->write(p_rarch->midi_drv_data, &event))
{
RARCH_ERR("[MIDI]: Volume change failed.\n");
return false;
}
return true;
}
static bool midi_driver_init_io_buffers(struct rarch_state *p_rarch)
{
uint8_t *midi_drv_input_buffer = (uint8_t*)malloc(MIDI_DRIVER_BUF_SIZE);
uint8_t *midi_drv_output_buffer = (uint8_t*)malloc(MIDI_DRIVER_BUF_SIZE);
if (!midi_drv_input_buffer || !midi_drv_output_buffer)
{
if (midi_drv_input_buffer)
free(midi_drv_input_buffer);
if (midi_drv_output_buffer)
free(midi_drv_output_buffer);
return false;
}
p_rarch->midi_drv_input_buffer = midi_drv_input_buffer;
p_rarch->midi_drv_output_buffer = midi_drv_output_buffer;
p_rarch->midi_drv_input_event.data = midi_drv_input_buffer;
p_rarch->midi_drv_input_event.data_size = 0;
p_rarch->midi_drv_output_event.data = midi_drv_output_buffer;
p_rarch->midi_drv_output_event.data_size = 0;
return true;
}
static void midi_driver_free(struct rarch_state *p_rarch)
{
if (p_rarch->midi_drv_data)
{
midi_drv->free(p_rarch->midi_drv_data);
p_rarch->midi_drv_data = NULL;
}
if (p_rarch->midi_drv_inputs)
{
string_list_free(p_rarch->midi_drv_inputs);
p_rarch->midi_drv_inputs = NULL;
}
if (p_rarch->midi_drv_outputs)
{
string_list_free(p_rarch->midi_drv_outputs);
p_rarch->midi_drv_outputs = NULL;
}
if (p_rarch->midi_drv_input_buffer)
{
free(p_rarch->midi_drv_input_buffer);
p_rarch->midi_drv_input_buffer = NULL;
}
if (p_rarch->midi_drv_output_buffer)
{
free(p_rarch->midi_drv_output_buffer);
p_rarch->midi_drv_output_buffer = NULL;
}
p_rarch->midi_drv_input_enabled = false;
p_rarch->midi_drv_output_enabled = false;
}
static bool midi_driver_init(struct rarch_state *p_rarch,
settings_t *settings)
{
union string_list_elem_attr attr = {0};
bool ret = true;
p_rarch->midi_drv_inputs = string_list_new();
p_rarch->midi_drv_outputs = string_list_new();
if (!p_rarch->midi_drv_inputs || !p_rarch->midi_drv_outputs)
ret = false;
else if (!string_list_append(p_rarch->midi_drv_inputs, "Off", attr) ||
!string_list_append(p_rarch->midi_drv_outputs, "Off", attr))
ret = false;
else
{
char * input = NULL;
char * output = NULL;
midi_drv = midi_driver_find_driver(
settings->arrays.midi_driver);
if (strcmp(midi_drv->ident, settings->arrays.midi_driver))
{
configuration_set_string(settings,
settings->arrays.midi_driver, midi_drv->ident);
}
if (!midi_drv->get_avail_inputs(p_rarch->midi_drv_inputs))
ret = false;
else if (!midi_drv->get_avail_outputs(p_rarch->midi_drv_outputs))
ret = false;
else
{
if (string_is_not_equal(settings->arrays.midi_input, "Off"))
{
if (string_list_find_elem(p_rarch->midi_drv_inputs, settings->arrays.midi_input))
input = settings->arrays.midi_input;
else
{
RARCH_WARN("[MIDI]: Input device \"%s\" unavailable.\n",
settings->arrays.midi_input);
configuration_set_string(settings,
settings->arrays.midi_input, "Off");
}
}
if (string_is_not_equal(settings->arrays.midi_output, "Off"))
{
if (string_list_find_elem(p_rarch->midi_drv_outputs, settings->arrays.midi_output))
output = settings->arrays.midi_output;
else
{
RARCH_WARN("[MIDI]: Output device \"%s\" unavailable.\n",
settings->arrays.midi_output);
configuration_set_string(settings,
settings->arrays.midi_output, "Off");
}
}
p_rarch->midi_drv_data = midi_drv->init(input, output);
if (!p_rarch->midi_drv_data)
ret = false;
else
{
p_rarch->midi_drv_input_enabled = (input != NULL);
p_rarch->midi_drv_output_enabled = (output != NULL);
if (!midi_driver_init_io_buffers(p_rarch))
ret = false;
else
{
if (input)
RARCH_LOG("[MIDI]: Input device \"%s\".\n", input);
if (output)
{
RARCH_LOG("[MIDI]: Output device \"%s\".\n", output);
midi_driver_set_volume(settings->uints.midi_volume);
}
}
}
}
}
if (!ret)
{
midi_driver_free(p_rarch);
RARCH_ERR("[MIDI]: Initialization failed.\n");
return false;
}
return true;
}
bool midi_driver_set_input(const char *input)
{
struct rarch_state *p_rarch = &rarch_st;
if (!p_rarch->midi_drv_data)
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: midi_driver_set_input called on uninitialized driver.\n");
#endif
return false;
}
if (string_is_equal(input, "Off"))
input = NULL;
if (!midi_drv->set_input(p_rarch->midi_drv_data, input))
{
if (input)
RARCH_ERR("[MIDI]: Failed to change input device to \"%s\".\n", input);
else
RARCH_ERR("[MIDI]: Failed to disable input.\n");
return false;
}
if (input)
RARCH_LOG("[MIDI]: Input device changed to \"%s\".\n", input);
else
RARCH_LOG("[MIDI]: Input disabled.\n");
p_rarch->midi_drv_input_enabled = input != NULL;
return true;
}
bool midi_driver_set_output(const char *output)
{
struct rarch_state *p_rarch = &rarch_st;
if (!p_rarch->midi_drv_data)
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: midi_driver_set_output called on uninitialized driver.\n");
#endif
return false;
}
if (string_is_equal(output, "Off"))
output = NULL;
if (!midi_drv->set_output(p_rarch->midi_drv_data, output))
{
if (output)
RARCH_ERR("[MIDI]: Failed to change output device to \"%s\".\n", output);
else
RARCH_ERR("[MIDI]: Failed to disable output.\n");
return false;
}
if (output)
{
settings_t *settings = p_rarch->configuration_settings;
p_rarch->midi_drv_output_enabled = true;
RARCH_LOG("[MIDI]: Output device changed to \"%s\".\n", output);
if (settings)
midi_driver_set_volume(settings->uints.midi_volume);
else
RARCH_ERR("[MIDI]: Volume change failed (settings unavailable).\n");
}
else
{
p_rarch->midi_drv_output_enabled = false;
RARCH_LOG("[MIDI]: Output disabled.\n");
}
return true;
}
static bool midi_driver_input_enabled(void)
{
struct rarch_state *p_rarch = &rarch_st;
return p_rarch->midi_drv_input_enabled;
}
static bool midi_driver_output_enabled(void)
{
struct rarch_state *p_rarch = &rarch_st;
return p_rarch->midi_drv_output_enabled;
}
static bool midi_driver_read(uint8_t *byte)
{
static int i;
struct rarch_state *p_rarch = &rarch_st;
if (!p_rarch->midi_drv_data || !p_rarch->midi_drv_input_enabled || !byte)
{
#ifdef DEBUG
if (!p_rarch->midi_drv_data)
RARCH_ERR("[MIDI]: midi_driver_read called on uninitialized driver.\n");
else if (!p_rarch->midi_drv_input_enabled)
RARCH_ERR("[MIDI]: midi_driver_read called when input is disabled.\n");
else
RARCH_ERR("[MIDI]: midi_driver_read called with null pointer.\n");
#endif
return false;
}
if (i == p_rarch->midi_drv_input_event.data_size)
{
p_rarch->midi_drv_input_event.data_size = MIDI_DRIVER_BUF_SIZE;
if (!midi_drv->read(p_rarch->midi_drv_data,
&p_rarch->midi_drv_input_event))
{
p_rarch->midi_drv_input_event.data_size = i;
return false;
}
i = 0;
#ifdef DEBUG
if (p_rarch->midi_drv_input_event.data_size == 1)
RARCH_LOG("[MIDI]: In [0x%02X].\n",
p_rarch->midi_drv_input_event.data[0]);
else if (p_rarch->midi_drv_input_event.data_size == 2)
RARCH_LOG("[MIDI]: In [0x%02X, 0x%02X].\n",
p_rarch->midi_drv_input_event.data[0],
p_rarch->midi_drv_input_event.data[1]);
else if (p_rarch->midi_drv_input_event.data_size == 3)
RARCH_LOG("[MIDI]: In [0x%02X, 0x%02X, 0x%02X].\n",
p_rarch->midi_drv_input_event.data[0],
p_rarch->midi_drv_input_event.data[1],
p_rarch->midi_drv_input_event.data[2]);
else
RARCH_LOG("[MIDI]: In [0x%02X, ...], size %u.\n",
p_rarch->midi_drv_input_event.data[0],
p_rarch->midi_drv_input_event.data_size);
#endif
}
*byte = p_rarch->midi_drv_input_event.data[i++];
return true;
}
static bool midi_driver_write(uint8_t byte, uint32_t delta_time)
{
static int event_size;
struct rarch_state *p_rarch = &rarch_st;
if (!p_rarch->midi_drv_data || !p_rarch->midi_drv_output_enabled)
{
#ifdef DEBUG
if (!p_rarch->midi_drv_data)
RARCH_ERR("[MIDI]: midi_driver_write called on uninitialized driver.\n");
else
RARCH_ERR("[MIDI]: midi_driver_write called when output is disabled.\n");
#endif
return false;
}
if (byte >= 0x80)
{
if (p_rarch->midi_drv_output_event.data_size &&
p_rarch->midi_drv_output_event.data[0] == 0xF0)
{
if (byte == 0xF7)
event_size = (int)p_rarch->midi_drv_output_event.data_size + 1;
else
{
if (!midi_drv->write(p_rarch->midi_drv_data,
&p_rarch->midi_drv_output_event))
return false;
#ifdef DEBUG
switch (p_rarch->midi_drv_output_event.data_size)
{
case 1:
RARCH_LOG("[MIDI]: Out [0x%02X].\n",
p_rarch->midi_drv_output_event.data[0]);
break;
case 2:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X].\n",
p_rarch->midi_drv_output_event.data[0],
p_rarch->midi_drv_output_event.data[1]);
break;
case 3:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X, 0x%02X].\n",
p_rarch->midi_drv_output_event.data[0],
p_rarch->midi_drv_output_event.data[1],
p_rarch->midi_drv_output_event.data[2]);
break;
default:
RARCH_LOG("[MIDI]: Out [0x%02X, ...], size %u.\n",
p_rarch->midi_drv_output_event.data[0],
p_rarch->midi_drv_output_event.data_size);
break;
}
#endif
p_rarch->midi_drv_output_pending = true;
event_size = (int)midi_driver_get_event_size(byte);
p_rarch->midi_drv_output_event.data_size = 0;
p_rarch->midi_drv_output_event.delta_time = 0;
}
}
else
{
event_size = (int)midi_driver_get_event_size(byte);
p_rarch->midi_drv_output_event.data_size = 0;
p_rarch->midi_drv_output_event.delta_time = 0;
}
}
if (p_rarch->midi_drv_output_event.data_size < MIDI_DRIVER_BUF_SIZE)
{
p_rarch->midi_drv_output_event.data[p_rarch->midi_drv_output_event.data_size] = byte;
++p_rarch->midi_drv_output_event.data_size;
p_rarch->midi_drv_output_event.delta_time += delta_time;
}
else
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: Output event dropped.\n");
#endif
return false;
}
if (p_rarch->midi_drv_output_event.data_size == event_size)
{
if (!midi_drv->write(p_rarch->midi_drv_data,
&p_rarch->midi_drv_output_event))
return false;
#ifdef DEBUG
switch (p_rarch->midi_drv_output_event.data_size)
{
case 1:
RARCH_LOG("[MIDI]: Out [0x%02X].\n",
p_rarch->midi_drv_output_event.data[0]);
break;
case 2:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X].\n",
p_rarch->midi_drv_output_event.data[0],
p_rarch->midi_drv_output_event.data[1]);
break;
case 3:
RARCH_LOG("[MIDI]: Out [0x%02X, 0x%02X, 0x%02X].\n",
p_rarch->midi_drv_output_event.data[0],
p_rarch->midi_drv_output_event.data[1],
p_rarch->midi_drv_output_event.data[2]);
break;
default:
RARCH_LOG("[MIDI]: Out [0x%02X, ...], size %u.\n",
p_rarch->midi_drv_output_event.data[0],
p_rarch->midi_drv_output_event.data_size);
break;
}
#endif
p_rarch->midi_drv_output_pending = true;
p_rarch->midi_drv_output_event.data_size = 0;
p_rarch->midi_drv_output_event.delta_time = 0;
}
return true;
}
static bool midi_driver_flush(void)
{
struct rarch_state *p_rarch = &rarch_st;
if (!p_rarch->midi_drv_data)
return false;
if (p_rarch->midi_drv_output_pending)
p_rarch->midi_drv_output_pending =
!midi_drv->flush(p_rarch->midi_drv_data);
return !p_rarch->midi_drv_output_pending;
}
size_t midi_driver_get_event_size(uint8_t status)
{
static const uint8_t midi_drv_ev_sizes[128] =
{
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
0, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
if (status < 0x80)
{
#ifdef DEBUG
RARCH_ERR("[MIDI]: midi_driver_get_event_size called with invalid status.\n");
#endif
return 0;
}
return midi_drv_ev_sizes[status - 0x80];
}
/* AUDIO */
static enum resampler_quality audio_driver_get_resampler_quality(
@ -26854,7 +26293,7 @@ static void drivers_init(struct rarch_state *p_rarch,
/* Initialize MIDI driver */
if (flags & DRIVER_MIDI_MASK)
midi_driver_init(p_rarch, settings);
midi_driver_init(settings);
#ifdef HAVE_LAKKA
cpu_scaling_driver_init();
@ -26950,7 +26389,7 @@ static void driver_uninit(struct rarch_state *p_rarch, int flags)
p_rarch->audio_driver_context_audio_data = NULL;
if (flags & DRIVER_MIDI_MASK)
midi_driver_free(p_rarch);
midi_driver_free();
#ifdef HAVE_LAKKA
cpu_scaling_driver_free();

51
retroarch_data.h
View File

@ -81,8 +81,6 @@
#define MENU_SOUND_FORMATS "ogg|mod|xm|s3m|mp3|flac|wav"
#define MIDI_DRIVER_BUF_SIZE 4096
/**
* db_to_gain:
* @db : Decibels.
@ -880,42 +878,6 @@ static const record_driver_t *record_drivers[] = {
NULL,
};
extern midi_driver_t midi_winmm;
extern midi_driver_t midi_alsa;
static void null_midi_free(void *p) { }
static void *null_midi_init(const char *input, const char *output) { return (void*)-1; }
static bool null_midi_get_avail_inputs(struct string_list *inputs) { union string_list_elem_attr attr = {0}; return string_list_append(inputs, "Null", attr); }
static bool null_midi_get_avail_outputs(struct string_list *outputs) { union string_list_elem_attr attr = {0}; return string_list_append(outputs, "Null", attr); }
static bool null_midi_set_input(void *p, const char *input) { return input == NULL || string_is_equal(input, "Null"); }
static bool null_midi_set_output(void *p, const char *output) { return output == NULL || string_is_equal(output, "Null"); }
static bool null_midi_read(void *p, midi_event_t *event) { return false; }
static bool null_midi_write(void *p, const midi_event_t *event) { return true; }
static bool null_midi_flush(void *p) { return true; }
static midi_driver_t midi_null = {
"null",
null_midi_get_avail_inputs,
null_midi_get_avail_outputs,
null_midi_init,
null_midi_free,
null_midi_set_input,
null_midi_set_output,
null_midi_read,
null_midi_write,
null_midi_flush
};
static midi_driver_t *midi_drivers[] = {
#if defined(HAVE_ALSA) && !defined(HAVE_HAKCHI) && !defined(HAVE_SEGAM) && !defined(DINGUX)
&midi_alsa,
#endif
#ifdef HAVE_WINMM
&midi_winmm,
#endif
&midi_null
};
static void *nullcamera_init(const char *device, uint64_t caps,
unsigned width, unsigned height) { return (void*)-1; }
static void nullcamera_free(void *data) { }
@ -1246,13 +1208,9 @@ struct rarch_state
#endif
struct string_list *subsystem_fullpaths;
struct string_list *midi_drv_inputs;
struct string_list *midi_drv_outputs;
struct string_list *audio_driver_devices_list;
uint8_t *video_driver_record_gpu_buffer;
uint8_t *midi_drv_input_buffer;
uint8_t *midi_drv_output_buffer;
bool *load_no_content_hook;
float *audio_driver_output_samples_buf;
char *osk_grid[45];
@ -1277,8 +1235,6 @@ struct rarch_state
const camera_driver_t *camera_driver;
void *camera_data;
void *midi_drv_data;
const ui_companion_driver_t *ui_companion;
void *ui_companion_data;
@ -1385,8 +1341,6 @@ struct rarch_state
gfx_ctx_driver_t current_video_context; /* ptr alignment */
content_state_t content_st; /* ptr alignment */
midi_event_t midi_drv_input_event; /* ptr alignment */
midi_event_t midi_drv_output_event; /* ptr alignment */
core_info_state_t core_info_st; /* ptr alignment */
struct retro_hw_render_callback hw_render; /* ptr alignment */
#ifdef HAVE_BSV_MOVIE
@ -1774,10 +1728,6 @@ struct rarch_state
bool recording_enable;
bool streaming_enable;
bool midi_drv_input_enabled;
bool midi_drv_output_enabled;
bool midi_drv_output_pending;
bool main_ui_companion_is_on_foreground;
bool keyboard_mapping_blocked;
@ -1818,7 +1768,6 @@ static runloop_core_status_msg_t runloop_core_status_msg =
extern u32 __nx_applet_type;
#endif
static midi_driver_t *midi_drv = &midi_null;
static const video_display_server_t *current_display_server = &dispserv_null;
struct aspect_ratio_elem aspectratio_lut[ASPECT_RATIO_END] = {

8
retroarch_fwd_decls.h
View File

@ -36,14 +36,6 @@ static void deinit_netplay(struct rarch_state *p_rarch);
static void retroarch_deinit_drivers(struct rarch_state *p_rarch,
struct retro_callbacks *cbs);
static bool midi_driver_read(uint8_t *byte);
static bool midi_driver_write(uint8_t byte, uint32_t delta_time);
static bool midi_driver_output_enabled(void);
static bool midi_driver_input_enabled(void);
static bool midi_driver_set_all_sounds_off(struct rarch_state *p_rarch);
static const void *midi_driver_find_handle(int index);
static bool midi_driver_flush(void);
static void retroarch_deinit_core_options(
bool game_options_active,
const char *path_core_options,