mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-01-29 18:32:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

(content) use flags for content_state

Browse Source 
(xaudio2) Use flags
This commit is contained in:
LibretroAdmin 2022-10-09 10:20:19 +02:00
parent 73f766f133
commit d5a6c4f150
4 changed files with 69 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
audio/drivers/xaudio.c
View File

@ -57,12 +57,17 @@ typedef struct xaudio2 xaudio2_t;
#define XAUDIO2_WRITE_AVAILABLE(handle) ((handle)->bufsize * (MAX_BUFFERS - (handle)->buffers - 1))
enum xa_flags
{
XA2_FLAG_NONBLOCK = (1 << 0),
XA2_FLAG_IS_PAUSED = (1 << 1)
};
typedef struct
{
xaudio2_t *xa;
size_t bufsize;
bool nonblock;
bool is_paused;
uint8_t flags;
} xa_t;
/* Forward declarations */
@ -323,8 +328,7 @@ static void *xa_init(const char *device, unsigned rate, unsigned latency,
bufsize = latency * rate / 1000;
xa->bufsize = bufsize * 2 * sizeof(float);
xa->xa = xaudio2_new(rate, 2, xa->bufsize, device);
if (!xa->xa)
if (!(xa->xa = xaudio2_new(rate, 2, xa->bufsize, device)))
{
RARCH_ERR("[XAudio2] Failed to init driver.\n");
free(xa);
@ -344,7 +348,7 @@ static ssize_t xa_write(void *data, const void *buf, size_t size)
xaudio2_t *handle = xa->xa;
const uint8_t *buffer = (const uint8_t*)buf;
if (xa->nonblock)
if (xa->flags & XA2_FLAG_NONBLOCK)
{
size_t avail = XAUDIO2_WRITE_AVAILABLE(xa->xa);
@ -403,8 +407,8 @@ static ssize_t xa_write(void *data, const void *buf, size_t size)
static bool xa_stop(void *data)
{
xa_t *xa = (xa_t*)data;
xa->is_paused = true;
xa_t *xa = (xa_t*)data;
xa->flags |= XA2_FLAG_IS_PAUSED;
return true;
}
@ -413,20 +417,25 @@ static bool xa_alive(void *data)
xa_t *xa = (xa_t*)data;
if (!xa)
return false;
return !xa->is_paused;
return !(xa->flags & XA2_FLAG_IS_PAUSED);
}
static void xa_set_nonblock_state(void *data, bool state)
{
xa_t *xa = (xa_t*)data;
if (xa)
xa->nonblock = state;
{
if (state)
xa->flags |= XA2_FLAG_NONBLOCK;
else
xa->flags &= ~XA2_FLAG_NONBLOCK;
}
}
static bool xa_start(void *data, bool is_shutdown)
{
xa_t *xa = (xa_t*)data;
xa->is_paused = false;
xa_t *xa = (xa_t*)data;
xa->flags &= ~(XA2_FLAG_IS_PAUSED);
return true;
}

26
gfx/video_driver.c
View File

@ -216,7 +216,7 @@ struct aspect_ratio_elem aspectratio_lut[ASPECT_RATIO_END] = {
static void *video_null_init(const video_info_t *video,
input_driver_t **input, void **input_data)
{
*input = NULL;
*input = NULL;
*input_data = NULL;
frontend_driver_install_signal_handler();
@ -224,21 +224,15 @@ static void *video_null_init(const video_info_t *video,
return (void*)-1;
}
static bool video_null_frame(void *data, const void *frame,
unsigned frame_width, unsigned frame_height, uint64_t frame_count,
unsigned pitch, const char *msg, video_frame_info_t *video_info)
{
return true;
}
static void video_null_free(void *data) { }
static void video_null_set_nonblock_state(void *a, bool b, bool c, unsigned d) { }
static bool video_null_alive(void *data) { return frontend_driver_get_signal_handler_state() != 1; }
static bool video_null_focus(void *data) { return true; }
static bool video_null_has_windowed(void *data) { return true; }
static bool video_null_suppress_screensaver(void *data, bool enable) { return false; }
static bool video_null_set_shader(void *data,
enum rarch_shader_type type, const char *path) { return false; }
static bool video_null_frame(void *, const void *, unsigned, unsigned, uint64_t,
unsigned, const char *, video_frame_info_t *) { return true; }
static void video_null_free(void *) { }
static void video_null_set_nonblock_state(void *, bool, bool, unsigned) { }
static bool video_null_alive(void *) { return frontend_driver_get_signal_handler_state() != 1; }
static bool video_null_focus(void *) { return true; }
static bool video_null_has_windowed(void *) { return true; }
static bool video_null_suppress_screensaver(void *, bool) { return false; }
static bool video_null_set_shader(void *, enum rarch_shader_type, const char *) { return false; }
video_driver_t video_null = {
video_null_init,

14
retroarch_types.h
View File

@ -367,6 +367,14 @@ typedef struct content_file_list
size_t size;
} content_file_list_t;
enum content_state_flags
{
CONTENT_ST_FLAG_IS_INITED = (1 << 0),
CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT = (1 << 1),
CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT = (1 << 2),
CONTENT_ST_FLAG_PENDING_ROM_CRC = (1 << 3)
};
typedef struct content_state
{
char *pending_subsystem_roms[RARCH_MAX_SUBSYSTEM_ROMS];
@ -378,16 +386,12 @@ typedef struct content_state
int pending_subsystem_id;
unsigned pending_subsystem_rom_id;
uint32_t rom_crc;
uint8_t flags;
char companion_ui_crc32[32];
char pending_subsystem_ident[255];
char pending_rom_crc_path[PATH_MAX_LENGTH];
char companion_ui_db_name[PATH_MAX_LENGTH];
bool is_inited;
bool core_does_not_need_content;
bool pending_subsystem_init;
bool pending_rom_crc;
} content_state_t;
RETRO_END_DECLS

57
tasks/task_content.c
View File

@ -759,7 +759,7 @@ static bool content_file_load_into_memory(
and then encode the CRC32 hash */
strlcpy(p_content->pending_rom_crc_path, content_path,
sizeof(p_content->pending_rom_crc_path));
p_content->pending_rom_crc = true;
p_content->flags |= CONTENT_ST_FLAG_PENDING_ROM_CRC;
}
}
else
@ -1105,7 +1105,7 @@ static bool content_file_load(
{
strlcpy(p_content->pending_rom_crc_path, content_path,
sizeof(p_content->pending_rom_crc_path));
p_content->pending_rom_crc = true;
p_content->flags |= CONTENT_ST_FLAG_PENDING_ROM_CRC;
}
else
p_content->rom_crc = 0;
@ -1461,7 +1461,7 @@ static bool content_load(content_ctx_info_t *info,
if (!success)
return false;
if (p_content->pending_subsystem_init)
if (p_content->flags & CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT)
{
command_event(CMD_EVENT_CORE_INIT, NULL);
content_clear_subsystem();
@ -2747,7 +2747,7 @@ bool task_push_load_subsystem_with_core(
{
content_state_t *p_content = content_state_get_ptr();
p_content->pending_subsystem_init = true;
p_content->flags |= CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT;
/* Load content */
#ifdef HAVE_MENU
if (!task_load_content_internal(content_info, true, false, false))
@ -2770,18 +2770,19 @@ void content_get_status(
{
content_state_t *p_content = content_state_get_ptr();
*contentless = p_content->core_does_not_need_content;
*is_inited = p_content->is_inited;
*contentless = (p_content->flags &
CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT);
*is_inited = (p_content->flags & CONTENT_ST_FLAG_IS_INITED);
}
/* Clears the pending subsystem rom buffer*/
void content_clear_subsystem(void)
{
unsigned i;
content_state_t *p_content = content_state_get_ptr();
content_state_t *p_content = content_state_get_ptr();
p_content->pending_subsystem_rom_id = 0;
p_content->pending_subsystem_init = false;
p_content->pending_subsystem_rom_id = 0;
p_content->flags &= ~CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT;
for (i = 0; i < RARCH_MAX_SUBSYSTEM_ROMS; i++)
{
@ -2897,13 +2898,13 @@ void content_add_subsystem(const char* path)
void content_set_does_not_need_content(void)
{
content_state_t *p_content = content_state_get_ptr();
p_content->core_does_not_need_content = true;
p_content->flags |= CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT;
}
void content_unset_does_not_need_content(void)
{
content_state_t *p_content = content_state_get_ptr();
p_content->core_does_not_need_content = false;
p_content->flags &= ~CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT;
}
#ifndef CRC32_BUFFER_SIZE
@ -2960,9 +2961,9 @@ static uint32_t file_crc32(uint32_t crc, const char *path)
uint32_t content_get_crc(void)
{
content_state_t *p_content = content_state_get_ptr();
if (p_content->pending_rom_crc)
if (p_content->flags & CONTENT_ST_FLAG_PENDING_ROM_CRC)
{
p_content->pending_rom_crc = false;
p_content->flags &= ~CONTENT_ST_FLAG_PENDING_ROM_CRC;
/* TODO/FIXME - file_crc32 has a 64MB max limit -
* get rid of this function and find a better
* way to calculate CRC based on the file */
@ -2983,7 +2984,7 @@ char* content_get_subsystem_rom(unsigned index)
bool content_is_inited(void)
{
content_state_t *p_content = content_state_get_ptr();
return p_content->is_inited;
return ((p_content->flags & CONTENT_ST_FLAG_IS_INITED) > 0);
}
void content_deinit(void)
@ -2995,16 +2996,18 @@ void content_deinit(void)
p_content->content_list = NULL;
p_content->rom_crc = 0;
p_content->is_inited = false;
p_content->core_does_not_need_content = false;
p_content->pending_rom_crc = false;
p_content->flags &= ~(CONTENT_ST_FLAG_PENDING_ROM_CRC
| CONTENT_ST_FLAG_CORE_DOES_NOT_NEED_CONTENT
| CONTENT_ST_FLAG_IS_INITED
)
;
}
/* Set environment variables before a subsystem load */
void content_set_subsystem_info(void)
{
content_state_t *p_content = content_state_get_ptr();
if (!p_content->pending_subsystem_init)
if (!(p_content->flags & CONTENT_ST_FLAG_PENDING_SUBSYSTEM_INIT))
return;
path_set(RARCH_PATH_SUBSYSTEM, p_content->pending_subsystem_ident);
@ -3067,28 +3070,28 @@ bool content_init(void)
if (sys_info)
{
struct retro_system_info *system = &runloop_state_get_ptr()->system.info;
struct retro_system_info *system = &runloop_state_get_ptr()->system.info;
if (set_supports_no_game_enable)
content_ctx.flags |= CONTENT_INFO_FLAG_SET_SUPPORTS_NO_GAME_ENABLE;
if (!string_is_empty(path_dir_system))
content_ctx.directory_system = strdup(path_dir_system);
content_ctx.directory_system = strdup(path_dir_system);
if (!string_is_empty(path_dir_cache))
content_ctx.directory_cache = strdup(path_dir_cache);
content_ctx.directory_cache = strdup(path_dir_cache);
if (!string_is_empty(system->valid_extensions))
content_ctx.valid_extensions = strdup(system->valid_extensions);
content_ctx.valid_extensions = strdup(system->valid_extensions);
if (system->block_extract)
content_ctx.flags |= CONTENT_INFO_FLAG_BLOCK_EXTRACT;
content_ctx.flags |= CONTENT_INFO_FLAG_BLOCK_EXTRACT;
if (system->need_fullpath)
content_ctx.flags |= CONTENT_INFO_FLAG_NEED_FULLPATH;
content_ctx.flags |= CONTENT_INFO_FLAG_NEED_FULLPATH;
content_ctx.subsystem.data = sys_info->subsystem.data;
content_ctx.subsystem.size = sys_info->subsystem.size;
content_ctx.subsystem.data = sys_info->subsystem.data;
content_ctx.subsystem.size = sys_info->subsystem.size;
}
p_content->is_inited = true;
p_content->flags |= CONTENT_ST_FLAG_IS_INITED;
if (string_list_initialize(&content))
{