RetroArch/gfx/video_state_tracker.c

298 lines
7.4 KiB
C
Raw Normal View History

2012-04-21 21:13:50 +00:00
/* RetroArch - A frontend for libretro.
2014-01-01 00:50:59 +00:00
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
2017-01-22 12:40:32 +00:00
* Copyright (C) 2011-2017 - Daniel De Matteis
*
2012-04-21 21:13:50 +00:00
* 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.
*
2012-04-21 21:13:50 +00:00
* 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.
*
2012-04-21 21:31:57 +00:00
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
2016-09-08 06:10:31 +00:00
2014-10-21 05:58:58 +00:00
#include <compat/strl.h>
#include <retro_inline.h>
2016-09-01 03:38:26 +00:00
2016-09-06 21:47:05 +00:00
#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif
#ifdef HAVE_PYTHON
#include "drivers_tracker/video_state_python.h"
#endif
2016-09-08 06:10:31 +00:00
#include "video_state_tracker.h"
2016-09-08 06:10:31 +00:00
#include "../input/input_config.h"
2016-09-08 06:10:31 +00:00
#include "../verbosity.h"
2012-04-07 10:17:40 +00:00
struct state_tracker_internal
{
char id[64];
2011-06-11 18:02:17 +00:00
bool is_input;
const uint16_t *input_ptr;
const uint8_t *ptr;
#ifdef HAVE_PYTHON
py_state_t *py;
#endif
uint32_t addr;
2012-02-12 17:05:33 +00:00
uint16_t mask;
uint16_t equal;
2012-04-07 10:17:40 +00:00
enum state_tracker_type type;
2011-06-11 18:02:17 +00:00
uint32_t prev[2];
int frame_count;
2011-06-07 19:07:00 +00:00
int frame_count_prev;
2011-06-11 18:02:17 +00:00
uint32_t old_value;
2011-06-06 19:32:10 +00:00
int transition_count;
};
2012-04-07 10:17:40 +00:00
struct state_tracker
{
2012-04-07 10:17:40 +00:00
struct state_tracker_internal *info;
unsigned info_elem;
2011-06-11 18:02:17 +00:00
uint16_t input_state[2];
#ifdef HAVE_PYTHON
py_state_t *py;
#endif
};
2015-01-11 21:39:50 +00:00
/**
* state_tracker_init:
* @info : State tracker info handle.
*
* Creates and initializes graphics state tracker.
*
* Returns: new state tracker handle if successful, otherwise NULL.
**/
2012-04-07 10:17:40 +00:00
state_tracker_t* state_tracker_init(const struct state_tracker_info *info)
{
unsigned i;
2016-12-25 00:52:40 +00:00
struct state_tracker_internal *tracker_info = NULL;
2017-01-12 09:41:11 +00:00
state_tracker_t *tracker = (state_tracker_t*)
calloc(1, sizeof(*tracker));
if (!tracker)
return NULL;
#ifdef HAVE_PYTHON
if (info->script)
{
2014-09-08 15:57:18 +00:00
tracker->py = py_state_new(info->script, info->script_is_file,
info->script_class ? info->script_class : "GameAware");
if (!tracker->py)
{
2017-01-12 09:41:11 +00:00
RARCH_ERR("Failed to initialize Python script.\n");
goto error;
}
}
#endif
2017-01-12 09:41:11 +00:00
tracker_info = (struct state_tracker_internal*)
2014-09-08 15:57:18 +00:00
calloc(info->info_elem, sizeof(struct state_tracker_internal));
2016-12-25 00:52:40 +00:00
if (!tracker_info)
2017-01-12 09:41:11 +00:00
goto error;
2016-12-25 00:52:40 +00:00
tracker->info = tracker_info;
tracker->info_elem = info->info_elem;
for (i = 0; i < info->info_elem; i++)
{
2015-01-07 21:18:03 +00:00
/* If we don't have a valid pointer. */
static const uint8_t empty = 0;
2014-09-08 15:57:18 +00:00
strlcpy(tracker->info[i].id, info->info[i].id,
sizeof(tracker->info[i].id));
2017-01-12 09:41:11 +00:00
2012-02-12 17:05:33 +00:00
tracker->info[i].addr = info->info[i].addr;
tracker->info[i].type = info->info[i].type;
2014-09-08 15:57:18 +00:00
tracker->info[i].mask = (info->info[i].mask == 0)
? 0xffff : info->info[i].mask;
2012-02-12 17:05:33 +00:00
tracker->info[i].equal = info->info[i].equal;
#ifdef HAVE_PYTHON
2012-04-21 21:25:32 +00:00
if (info->info[i].type == RARCH_STATE_PYTHON)
2012-11-18 20:23:34 +00:00
{
if (!tracker->py)
{
RARCH_ERR("Python semantic was requested, but Python tracker is not loaded.\n");
2017-01-12 09:41:11 +00:00
free(tracker->info);
goto error;
2012-11-18 20:23:34 +00:00
}
tracker->info[i].py = tracker->py;
2012-11-18 20:23:34 +00:00
}
#endif
switch (info->info[i].ram_type)
{
2012-04-21 21:25:32 +00:00
case RARCH_STATE_WRAM:
tracker->info[i].ptr = info->wram ? info->wram : &empty;
break;
2012-04-21 21:25:32 +00:00
case RARCH_STATE_INPUT_SLOT1:
2011-06-11 18:02:17 +00:00
tracker->info[i].input_ptr = &tracker->input_state[0];
tracker->info[i].is_input = true;
break;
2012-04-21 21:25:32 +00:00
case RARCH_STATE_INPUT_SLOT2:
2011-06-11 18:02:17 +00:00
tracker->info[i].input_ptr = &tracker->input_state[1];
tracker->info[i].is_input = true;
break;
default:
tracker->info[i].ptr = &empty;
}
}
return tracker;
2017-01-12 09:41:11 +00:00
error:
RARCH_ERR("Allocation of state tracker info failed.\n");
free(tracker);
return NULL;
}
2015-01-11 21:39:50 +00:00
/**
* state_tracker_free:
* @tracker : State tracker handle.
*
* Frees a state tracker handle.
**/
2012-04-07 10:17:40 +00:00
void state_tracker_free(state_tracker_t *tracker)
{
if (tracker)
{
free(tracker->info);
#ifdef HAVE_PYTHON
py_state_free(tracker->py);
#endif
}
free(tracker);
}
static INLINE uint16_t state_tracker_fetch(
2015-01-12 01:15:35 +00:00
const struct state_tracker_internal *info)
2012-02-12 17:05:33 +00:00
{
2015-01-07 21:18:03 +00:00
uint16_t val = info->ptr[info->addr];
2012-02-12 17:05:33 +00:00
if (info->is_input)
val = *info->input_ptr;
val &= info->mask;
if (info->equal && val != info->equal)
val = 0;
return val;
}
2011-05-29 21:58:04 +00:00
2015-01-12 01:15:35 +00:00
static void state_tracker_update_element(
2012-04-07 10:17:40 +00:00
struct state_tracker_uniform *uniform,
struct state_tracker_internal *info,
unsigned frame_count)
{
uniform->id = info->id;
switch (info->type)
{
2012-04-21 21:25:32 +00:00
case RARCH_STATE_CAPTURE:
2015-01-12 01:15:35 +00:00
uniform->value = state_tracker_fetch(info);
break;
2012-04-21 21:25:32 +00:00
case RARCH_STATE_CAPTURE_PREV:
2015-01-12 01:15:35 +00:00
if (info->prev[0] != state_tracker_fetch(info))
2011-05-26 14:23:11 +00:00
{
info->prev[1] = info->prev[0];
2015-01-12 01:15:35 +00:00
info->prev[0] = state_tracker_fetch(info);
2011-05-26 14:23:11 +00:00
}
uniform->value = info->prev[1];
break;
2012-04-21 21:25:32 +00:00
case RARCH_STATE_TRANSITION:
2015-01-12 01:15:35 +00:00
if (info->old_value != state_tracker_fetch(info))
{
2015-01-12 01:15:35 +00:00
info->old_value = state_tracker_fetch(info);
info->frame_count = frame_count;
}
2011-05-26 14:23:11 +00:00
uniform->value = info->frame_count;
break;
2012-04-21 21:25:32 +00:00
case RARCH_STATE_TRANSITION_COUNT:
2015-01-12 01:15:35 +00:00
if (info->old_value != state_tracker_fetch(info))
2011-06-06 19:32:10 +00:00
{
2015-01-12 01:15:35 +00:00
info->old_value = state_tracker_fetch(info);
2011-06-06 19:32:10 +00:00
info->transition_count++;
}
uniform->value = info->transition_count;
break;
2012-04-21 21:25:32 +00:00
case RARCH_STATE_TRANSITION_PREV:
2015-01-12 01:15:35 +00:00
if (info->old_value != state_tracker_fetch(info))
{
2015-01-12 01:15:35 +00:00
info->old_value = state_tracker_fetch(info);
2011-06-07 19:07:00 +00:00
info->frame_count_prev = info->frame_count;
2011-05-26 14:23:11 +00:00
info->frame_count = frame_count;
}
2011-06-07 19:07:00 +00:00
uniform->value = info->frame_count_prev;
2011-05-26 14:23:11 +00:00
break;
#ifdef HAVE_PYTHON
2012-04-21 21:25:32 +00:00
case RARCH_STATE_PYTHON:
uniform->value = py_state_get(info->py, info->id, frame_count);
break;
#endif
default:
break;
}
}
void state_tracker_update_input(uint16_t *input1, uint16_t *input2);
2011-06-11 18:02:17 +00:00
2015-01-11 21:39:50 +00:00
/**
2015-01-12 01:15:35 +00:00
* state_tracker_get_uniform:
2015-01-11 21:39:50 +00:00
* @tracker : State tracker handle.
* @uniforms : State tracker uniforms.
* @elem : Amount of uniform elements.
* @frame_count : Frame count.
*
2015-01-12 01:15:35 +00:00
* Calls state_tracker_update_input(), and updates each uniform
2015-01-11 21:39:50 +00:00
* element accordingly.
*
* Returns: Amount of state elements (either equal to @elem
* or equal to @tracker->info_eleme).
**/
2015-01-12 01:15:35 +00:00
unsigned state_tracker_get_uniform(state_tracker_t *tracker,
2014-09-08 15:57:18 +00:00
struct state_tracker_uniform *uniforms,
unsigned elem, unsigned frame_count)
{
2015-01-09 00:23:58 +00:00
unsigned i, elems = elem;
if (tracker->info_elem < elem)
elems = tracker->info_elem;
state_tracker_update_input(&tracker->input_state[0], &tracker->input_state[1]);
2011-06-11 18:02:17 +00:00
for (i = 0; i < elems; i++)
2015-01-12 01:15:35 +00:00
state_tracker_update_element(
&uniforms[i], &tracker->info[i], frame_count);
return elems;
}