/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2011-2017 - Higor Euripedes
*
* 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 <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <SDL/SDL_video.h>
#include <retro_assert.h>
#include <gfx/video_frame.h>
#include <retro_assert.h>
#include <string/stdstring.h>
#include <encodings/utf.h>
#include <features/features_cpu.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
#endif
#ifdef HAVE_MENU
#include "../../menu/menu_driver.h"
#endif
#include "../../dingux/dingux_utils.h"
#include "../../verbosity.h"
#include "../../gfx/drivers_font_renderer/bitmap.h"
#include "../../configuration.h"
#include "../../retroarch.h"
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#define SDL_DINGUX_MENU_WIDTH 320
#define SDL_DINGUX_MENU_HEIGHT 240
#define SDL_DINGUX_NUM_FONT_GLYPHS 256
#define SDL_DINGUX_FF_FRAME_TIME_MIN 16667
typedef struct sdl_dingux_video
{
retro_time_t last_frame_time;
SDL_Surface *screen;
bitmapfont_lut_t *osd_font;
unsigned frame_width;
unsigned frame_height;
unsigned frame_padding;
enum dingux_ipu_filter_type filter_type;
uint32_t font_colour32;
uint16_t font_colour16;
uint16_t menu_texture[SDL_DINGUX_MENU_WIDTH * SDL_DINGUX_MENU_HEIGHT];
bool rgb32;
bool vsync;
bool keep_aspect;
bool integer_scaling;
bool menu_active;
bool was_in_menu;
bool quitting;
bool mode_valid;
} sdl_dingux_video_t;
static void sdl_dingux_init_font_color(sdl_dingux_video_t *vid)
{
settings_t *settings = config_get_ptr();
uint32_t red = 0xFF;
uint32_t green = 0xFF;
uint32_t blue = 0xFF;
if (settings)
{
red = (uint32_t)((settings->floats.video_msg_color_r * 255.0f) + 0.5f) & 0xFF;
green = (uint32_t)((settings->floats.video_msg_color_g * 255.0f) + 0.5f) & 0xFF;
blue = (uint32_t)((settings->floats.video_msg_color_b * 255.0f) + 0.5f) & 0xFF;
}
/* Convert to XRGB8888 */
vid->font_colour32 = (red << 16) | (green << 8) | blue;
/* Convert to RGB565 */
red = red >> 3;
green = green >> 3;
blue = blue >> 3;
vid->font_colour16 = (red << 11) | (green << 6) | blue;
}
static void sdl_dingux_blit_text16(
sdl_dingux_video_t *vid,
unsigned x, unsigned y,
const char *str)
{
/* Note: Cannot draw text in padding region
* (padding region is never cleared, so
* any text pixels would remain as garbage) */
uint16_t *screen_buf = (uint16_t*)vid->screen->pixels;
bool **font_lut = vid->osd_font->lut;
/* 16 bit - divide pitch by 2 */
uint16_t screen_stride = (uint16_t)(vid->screen->pitch >> 1);
uint16_t screen_width = vid->screen->w;
uint16_t screen_height = vid->screen->h;
unsigned x_pos = x + vid->frame_padding;
uint16_t shadow_color_buf[2] = {0};
uint16_t color_buf[2];
color_buf[0] = vid->font_colour16;
color_buf[1] = 0;
/* Check for out of bounds y coordinates */
if (y + FONT_HEIGHT + 1 >= screen_height)
return;
while (!string_is_empty(str))
{
/* Check for out of bounds x coordinates */
if (x_pos + FONT_WIDTH_STRIDE + 1 >=
screen_width - vid->frame_padding)
return;
/* Deal with spaces first, for efficiency */
if (*str == ' ')
str++;
else
{
uint16_t i, j;
bool *symbol_lut;
uint32_t symbol = utf8_walk(&str);
/* Stupid hack: 'oe' ligatures are not really
* standard extended ASCII, so we have to waste
* CPU cycles performing a conversion from the
* unicode values... */
if (symbol == 339) /* Latin small ligature oe */
symbol = 156;
if (symbol == 338) /* Latin capital ligature oe */
symbol = 140;
if (symbol >= SDL_DINGUX_NUM_FONT_GLYPHS)
continue;
symbol_lut = font_lut[symbol];
for (j = 0; j < FONT_HEIGHT; j++)
{
uint32_t buff_offset = ((y + j) * screen_stride) + x_pos;
for (i = 0; i < FONT_WIDTH; i++)
{
if (*(symbol_lut + i + (j * FONT_WIDTH)))
{
uint16_t *screen_buf_ptr = screen_buf + buff_offset + i;
/* Text pixel + right shadow */
memcpy(screen_buf_ptr, color_buf, sizeof(uint16_t));
/* Bottom shadow */
screen_buf_ptr += screen_stride;
memcpy(screen_buf_ptr, shadow_color_buf, sizeof(uint16_t));
}
}
}
}
x_pos += FONT_WIDTH_STRIDE;
}
}
static void sdl_dingux_blit_text32(
sdl_dingux_video_t *vid,
unsigned x, unsigned y,
const char *str)
{
/* Note: Cannot draw text in padding region
* (padding region is never cleared, so
* any text pixels would remain as garbage) */
uint32_t *screen_buf = (uint32_t*)vid->screen->pixels;
bool **font_lut = vid->osd_font->lut;
/* 32 bit - divide pitch by 4 */
uint32_t screen_stride = (uint32_t)(vid->screen->pitch >> 2);
uint32_t screen_width = vid->screen->w;
uint32_t screen_height = vid->screen->h;
unsigned x_pos = x + vid->frame_padding;
uint32_t shadow_color_buf[2] = {0};
uint32_t color_buf[2];
color_buf[0] = vid->font_colour32;
color_buf[1] = 0;
/* Check for out of bounds y coordinates */
if (y + FONT_HEIGHT + 1 >= screen_height)
return;
while (!string_is_empty(str))
{
/* Check for out of bounds x coordinates */
if (x_pos + FONT_WIDTH_STRIDE + 1 >=
screen_width - vid->frame_padding)
return;
/* Deal with spaces first, for efficiency */
if (*str == ' ')
str++;
else
{
uint32_t i, j;
bool *symbol_lut;
uint32_t symbol = utf8_walk(&str);
/* Stupid hack: 'oe' ligatures are not really
* standard extended ASCII, so we have to waste
* CPU cycles performing a conversion from the
* unicode values... */
if (symbol == 339) /* Latin small ligature oe */
symbol = 156;
if (symbol == 338) /* Latin capital ligature oe */
symbol = 140;
if (symbol >= SDL_DINGUX_NUM_FONT_GLYPHS)
continue;
symbol_lut = font_lut[symbol];
for (j = 0; j < FONT_HEIGHT; j++)
{
uint32_t buff_offset = ((y + j) * screen_stride) + x_pos;
for (i = 0; i < FONT_WIDTH; i++)
{
if (*(symbol_lut + i + (j * FONT_WIDTH)))
{
uint32_t *screen_buf_ptr = screen_buf + buff_offset + i;
/* Text pixel + right shadow */
memcpy(screen_buf_ptr, color_buf, sizeof(uint32_t));
/* Bottom shadow */
screen_buf_ptr += screen_stride;
memcpy(screen_buf_ptr, shadow_color_buf, sizeof(uint32_t));
}
}
}
}
x_pos += FONT_WIDTH_STRIDE;
}
}
static void sdl_dingux_blit_video_mode_error_msg(sdl_dingux_video_t *vid)
{
const char *error_msg = msg_hash_to_str(MSG_UNSUPPORTED_VIDEO_MODE);
char display_mode[64];
display_mode[0] = '\0';
/* Zero out pixel buffer */
memset(vid->screen->pixels, 0,
vid->screen->w * vid->screen->w *
(vid->rgb32 ? sizeof(uint32_t) : sizeof(uint16_t)));
/* Generate display mode string */
snprintf(display_mode, sizeof(display_mode), "> %ux%u, %s",
vid->frame_width, vid->frame_height,
vid->rgb32 ? "XRGB8888" : "RGB565");
/* Print error message */
if (vid->rgb32)
{
sdl_dingux_blit_text32(vid,
FONT_WIDTH_STRIDE, FONT_WIDTH_STRIDE,
error_msg);
sdl_dingux_blit_text32(vid,
FONT_WIDTH_STRIDE, FONT_WIDTH_STRIDE + FONT_HEIGHT_STRIDE,
display_mode);
}
else
{
sdl_dingux_blit_text16(vid,
FONT_WIDTH_STRIDE, FONT_WIDTH_STRIDE,
error_msg);
sdl_dingux_blit_text16(vid,
FONT_WIDTH_STRIDE, FONT_WIDTH_STRIDE + FONT_HEIGHT_STRIDE,
display_mode);
}
}
static void sdl_dingux_gfx_free(void *data)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
if (!vid)
return;
SDL_QuitSubSystem(SDL_INIT_VIDEO);
/* It is good manners to leave IPU scaling
* parameters in the default state when
* shutting down */
if (!vid->keep_aspect)
dingux_ipu_set_aspect_ratio_enable(true);
if (vid->integer_scaling)
dingux_ipu_set_integer_scaling_enable(false);
if (vid->filter_type != DINGUX_IPU_FILTER_BICUBIC)
dingux_ipu_set_filter_type(DINGUX_IPU_FILTER_BICUBIC);
if (vid->osd_font)
bitmapfont_free_lut(vid->osd_font);
free(vid);
}
static void sdl_dingux_input_driver_init(
const char *input_driver_name, const char *joypad_driver_name,
input_driver_t **input, void **input_data)
{
/* Sanity check */
if (!input || !input_data)
return;
*input = NULL;
*input_data = NULL;
/* If input driver name is empty, cannot
* initialise anything... */
if (string_is_empty(input_driver_name))
return;
#if defined(HAVE_SDL_DINGUX)
if (string_is_equal(input_driver_name, "sdl_dingux"))
{
*input_data = input_driver_init_wrap(&input_sdl_dingux,
joypad_driver_name);
if (*input_data)
*input = &input_sdl_dingux;
return;
}
#endif
#if defined(HAVE_SDL) || defined(HAVE_SDL2)
if (string_is_equal(input_driver_name, "sdl"))
{
*input_data = input_driver_init_wrap(&input_sdl,
joypad_driver_name);
if (*input_data)
*input = &input_sdl;
return;
}
#endif
#if defined(HAVE_UDEV)
if (string_is_equal(input_driver_name, "udev"))
{
*input_data = input_driver_init_wrap(&input_udev,
joypad_driver_name);
if (*input_data)
*input = &input_udev;
return;
}
#endif
#if defined(__linux__)
if (string_is_equal(input_driver_name, "linuxraw"))
{
*input_data = input_driver_init_wrap(&input_linuxraw,
joypad_driver_name);
if (*input_data)
*input = &input_linuxraw;
return;
}
#endif
}
static void *sdl_dingux_gfx_init(const video_info_t *video,
input_driver_t **input, void **input_data)
{
sdl_dingux_video_t *vid = NULL;
settings_t *settings = config_get_ptr();
bool ipu_keep_aspect = settings->bools.video_dingux_ipu_keep_aspect;
bool ipu_integer_scaling = settings->bools.video_scale_integer;
enum dingux_ipu_filter_type ipu_filter_type = (enum dingux_ipu_filter_type)
settings->uints.video_dingux_ipu_filter_type;
const char *input_driver_name = settings->arrays.input_driver;
const char *joypad_driver_name = settings->arrays.input_joypad_driver;
uint32_t surface_flags = (video->vsync) ?
(SDL_HWSURFACE | SDL_TRIPLEBUF | SDL_FULLSCREEN) :
(SDL_HWSURFACE | SDL_FULLSCREEN);
dingux_ipu_set_downscaling_enable(true);
dingux_ipu_set_aspect_ratio_enable(ipu_keep_aspect);
dingux_ipu_set_integer_scaling_enable(ipu_integer_scaling);
dingux_ipu_set_filter_type(ipu_filter_type);
if (SDL_WasInit(0) == 0)
{
if (SDL_Init(SDL_INIT_VIDEO) < 0)
return NULL;
}
else if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
return NULL;
vid = (sdl_dingux_video_t*)calloc(1, sizeof(*vid));
if (!vid)
return NULL;
vid->screen = SDL_SetVideoMode(
SDL_DINGUX_MENU_WIDTH, SDL_DINGUX_MENU_HEIGHT,
video->rgb32 ? 32 : 16,
surface_flags);
if (!vid->screen)
{
RARCH_ERR("[SDL1]: Failed to init SDL surface: %s\n", SDL_GetError());
goto error;
}
vid->frame_width = SDL_DINGUX_MENU_WIDTH;
vid->frame_height = SDL_DINGUX_MENU_HEIGHT;
vid->rgb32 = video->rgb32;
vid->vsync = video->vsync;
vid->keep_aspect = ipu_keep_aspect;
vid->integer_scaling = ipu_integer_scaling;
vid->filter_type = ipu_filter_type;
vid->menu_active = false;
vid->was_in_menu = false;
vid->quitting = false;
vid->mode_valid = true;
vid->last_frame_time = 0;
SDL_ShowCursor(SDL_DISABLE);
sdl_dingux_input_driver_init(input_driver_name,
joypad_driver_name, input, input_data);
/* Initialise OSD font */
sdl_dingux_init_font_color(vid);
vid->osd_font = bitmapfont_get_lut();
if (!vid->osd_font ||
vid->osd_font->glyph_max <
(SDL_DINGUX_NUM_FONT_GLYPHS - 1))
{
RARCH_ERR("[SDL1]: Failed to init OSD font\n");
goto error;
}
return vid;
error:
sdl_dingux_gfx_free(vid);
return NULL;
}
static void sdl_dingux_set_output(
sdl_dingux_video_t* vid,
unsigned width, unsigned height, bool rgb32)
{
/* Surface width must be rounded up to
* the nearest multiple of 16 */
unsigned sanitized_width = (width + 0xF) & ~0xF;
uint32_t surface_flags = (vid->vsync) ?
(SDL_HWSURFACE | SDL_TRIPLEBUF | SDL_FULLSCREEN) :
(SDL_HWSURFACE | SDL_FULLSCREEN);
/* Cache set parameters */
vid->frame_width = width;
vid->frame_height = height;
/* Attempt to change video mode */
vid->screen = SDL_SetVideoMode(
sanitized_width, vid->frame_height,
rgb32 ? 32 : 16,
surface_flags);
/* Check whether selected display mode is valid */
if (unlikely(!vid->screen))
{
RARCH_ERR("[SDL1]: Failed to init SDL surface: %s\n", SDL_GetError());
/* We must have a valid SDL surface
* > Use known good fallback display mode
* (i.e. menu resolution)
* > We do not check for success here, because
* this cannot fail - and if it did, there is
* nothing we can do about it anyway... */
vid->screen = SDL_SetVideoMode(
SDL_DINGUX_MENU_WIDTH, SDL_DINGUX_MENU_HEIGHT,
rgb32 ? 32 : 16,
surface_flags);
vid->frame_padding = 0;
vid->mode_valid = false;
}
else
{
/* Determine whether horizontal padding
* is required */
if (sanitized_width != width)
{
vid->frame_padding = (sanitized_width - width) >> 1;
/* To prevent garbage pixels in the padding
* region, must zero out pixel buffer */
if (SDL_MUSTLOCK(vid->screen))
SDL_LockSurface(vid->screen);
memset(vid->screen->pixels, 0,
vid->screen->w * vid->screen->w *
(rgb32 ? sizeof(uint32_t) : sizeof(uint16_t)));
if (SDL_MUSTLOCK(vid->screen))
SDL_UnlockSurface(vid->screen);
}
else
vid->frame_padding = 0;
vid->mode_valid = true;
}
}
static void sdl_dingux_blit_frame16(sdl_dingux_video_t *vid,
uint16_t* src, unsigned width, unsigned height,
unsigned src_pitch)
{
uint16_t *in_ptr = src;
uint16_t *out_ptr = (uint16_t*)vid->screen->pixels;
unsigned dst_pitch = vid->screen->pitch;
/* If source and destination buffers have the
* same pitch, perform fast copy of raw pixel data */
if (src_pitch == dst_pitch)
memcpy(out_ptr, in_ptr, src_pitch * height);
else
{
/* Otherwise copy pixel data line-by-line */
/* 16 bit - divide pitch by 2 */
uint16_t in_stride = (uint16_t)(src_pitch >> 1);
uint16_t out_stride = (uint16_t)(dst_pitch >> 1);
size_t y;
/* If SDL surface has horizontal padding,
* shift output image to the right */
out_ptr += vid->frame_padding;
for (y = 0; y < height; y++)
{
memcpy(out_ptr, in_ptr, width * sizeof(uint16_t));
in_ptr += in_stride;
out_ptr += out_stride;
}
}
}
static void sdl_dingux_blit_frame32(sdl_dingux_video_t *vid,
uint32_t* src, unsigned width, unsigned height,
unsigned src_pitch)
{
uint32_t *in_ptr = src;
uint32_t *out_ptr = (uint32_t*)vid->screen->pixels;
unsigned dst_pitch = vid->screen->pitch;
/* If source and destination buffers have the
* same pitch, perform fast copy of raw pixel data */
if (src_pitch == dst_pitch)
memcpy(out_ptr, in_ptr, src_pitch * height);
else
{
/* Otherwise copy pixel data line-by-line */
/* 32 bit - divide pitch by 4 */
uint32_t in_stride = (uint32_t)(src_pitch >> 2);
uint32_t out_stride = (uint32_t)(dst_pitch >> 2);
size_t y;
/* If SDL surface has horizontal padding,
* shift output image to the right */
out_ptr += vid->frame_padding;
for (y = 0; y < height; y++)
{
memcpy(out_ptr, in_ptr, width * sizeof(uint32_t));
in_ptr += in_stride;
out_ptr += out_stride;
}
}
}
static bool sdl_dingux_gfx_frame(void *data, const void *frame,
unsigned width, unsigned height, uint64_t frame_count,
unsigned pitch, const char *msg, video_frame_info_t *video_info)
{
sdl_dingux_video_t* vid = (sdl_dingux_video_t*)data;
if (unlikely(!frame))
return true;
/* If fast forward is currently active, we may
* push frames at an 'unlimited' rate. Since the
* display has a fixed refresh rate of 60 Hz, this
* represents wasted effort. We therefore drop any
* 'excess' frames in this case.
* (Note that we *only* do this when fast forwarding.
* Attempting this trick while running content normally
* will cause bad frame pacing) */
if (unlikely(video_info->input_driver_nonblock_state))
{
retro_time_t current_time = cpu_features_get_time_usec();
if ((current_time - vid->last_frame_time) <
SDL_DINGUX_FF_FRAME_TIME_MIN)
return true;
vid->last_frame_time = current_time;
}
#ifdef HAVE_MENU
menu_driver_frame(video_info->menu_is_alive, video_info);
#endif
if (likely(!vid->menu_active))
{
/* Update video mode if we were in the menu on
* the previous frame, or width/height have changed */
if (unlikely(
vid->was_in_menu ||
(vid->frame_width != width) ||
(vid->frame_height != height)))
sdl_dingux_set_output(vid, width, height, vid->rgb32);
/* Must always lock SDL surface before
* manipulating raw pixel buffer */
if (SDL_MUSTLOCK(vid->screen))
SDL_LockSurface(vid->screen);
if (likely(vid->mode_valid))
{
/* Blit frame to SDL surface */
if (vid->rgb32)
sdl_dingux_blit_frame32(vid, (uint32_t*)frame,
width, height, pitch);
else
sdl_dingux_blit_frame16(vid, (uint16_t*)frame,
width, height, pitch);
}
/* If current display mode is invalid,
* just display an error message */
else
sdl_dingux_blit_video_mode_error_msg(vid);
vid->was_in_menu = false;
}
else
{
/* If this is the first frame that the menu
* is active, update video mode */
if (!vid->was_in_menu)
{
sdl_dingux_set_output(vid,
SDL_DINGUX_MENU_WIDTH, SDL_DINGUX_MENU_HEIGHT, false);
vid->was_in_menu = true;
}
if (SDL_MUSTLOCK(vid->screen))
SDL_LockSurface(vid->screen);
/* Blit menu texture to SDL surface */
sdl_dingux_blit_frame16(vid, vid->menu_texture,
SDL_DINGUX_MENU_WIDTH, SDL_DINGUX_MENU_HEIGHT,
SDL_DINGUX_MENU_WIDTH * sizeof(uint16_t));
}
/* Print OSD text, if required */
if (msg)
{
/* If menu is active, colour depth is overridden
* to 16 bit */
if (vid->rgb32 && !vid->menu_active)
sdl_dingux_blit_text32(vid, FONT_WIDTH_STRIDE,
vid->screen->h - (FONT_HEIGHT + FONT_WIDTH_STRIDE), msg);
else
sdl_dingux_blit_text16(vid, FONT_WIDTH_STRIDE,
vid->screen->h - (FONT_HEIGHT + FONT_WIDTH_STRIDE), msg);
}
/* Pixel manipulation complete - unlock
* SDL surface */
if (SDL_MUSTLOCK(vid->screen))
SDL_UnlockSurface(vid->screen);
SDL_Flip(vid->screen);
return true;
}
static void sdl_dingux_set_texture_enable(void *data, bool state, bool full_screen)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
(void)full_screen;
if (vid->menu_active != state)
vid->menu_active = state;
}
static void sdl_dingux_set_texture_frame(void *data, const void *frame, bool rgb32,
unsigned width, unsigned height, float alpha)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
if (unlikely(
rgb32 ||
(width > SDL_DINGUX_MENU_WIDTH) ||
(height > SDL_DINGUX_MENU_HEIGHT)))
return;
memcpy(vid->menu_texture, frame, width * height * sizeof(uint16_t));
}
static void sdl_dingux_gfx_set_nonblock_state(void *data, bool toggle,
bool adaptive_vsync_enabled, unsigned swap_interval)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
bool vsync = !toggle;
if (unlikely(!vid))
return;
/* Check whether vsync status has changed */
if (vid->vsync != vsync)
{
unsigned current_width = vid->frame_width;
unsigned current_height = vid->frame_height;
vid->vsync = vsync;
/* Update video mode */
/* Note that a tedious workaround is required...
* - Calling SDL_SetVideoMode() with the currently
* set width, height and pixel format can randomly
* become a noop even if the surface flags change.
* - Since all we are doing here is changing the VSYNC
* parameter (which just modifies surface flags), this
* means the VSYNC toggle may not be registered...
* - This is a huge problem when enabling fast forward,
* because VSYNC ON effectively limits maximum frame
* rate - if we push frames too rapidly, the OS chokes
* and the display freezes.
* We have to ensure that the VSYNC state change is
* applied in all cases. We can only do this by forcing
* a 'real' video mode update, which means adjusting the
* video resolution. We therefore end up calling
* sdl_dingux_set_output() *twice*, setting the dimensions
* to an arbitrary value before restoring the actual
* desired width/height */
sdl_dingux_set_output(vid,
current_width,
(current_height > 4) ? (current_height - 2) : 16,
vid->rgb32);
sdl_dingux_set_output(vid,
current_width, current_height, vid->rgb32);
}
}
static void sdl_dingux_gfx_check_window(sdl_dingux_video_t *vid)
{
SDL_Event event;
SDL_PumpEvents();
while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_QUITMASK))
{
if (event.type != SDL_QUIT)
continue;
vid->quitting = true;
break;
}
}
static bool sdl_dingux_gfx_alive(void *data)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
sdl_dingux_gfx_check_window(vid);
return !vid->quitting;
}
static bool sdl_dingux_gfx_focus(void *data)
{
return true;
}
static bool sdl_dingux_gfx_suppress_screensaver(void *data, bool enable)
{
return false;
}
static bool sdl_dingux_gfx_has_windowed(void *data)
{
return false;
}
static void sdl_dingux_gfx_viewport_info(void *data, struct video_viewport *vp)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
vp->x = 0;
vp->y = 0;
vp->width = vp->full_width = vid->frame_width;
vp->height = vp->full_height = vid->frame_height;
}
static void sdl_dingux_set_filtering(void *data, unsigned index, bool smooth, bool ctx_scaling)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
settings_t *settings = config_get_ptr();
enum dingux_ipu_filter_type ipu_filter_type = (settings) ?
(enum dingux_ipu_filter_type)settings->uints.video_dingux_ipu_filter_type :
DINGUX_IPU_FILTER_BICUBIC;
if (!vid || !settings)
return;
/* Update IPU filter setting, if required */
if (vid->filter_type != ipu_filter_type)
{
dingux_ipu_set_filter_type(ipu_filter_type);
vid->filter_type = ipu_filter_type;
}
}
static void sdl_dingux_apply_state_changes(void *data)
{
sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
settings_t *settings = config_get_ptr();
bool ipu_keep_aspect = (settings) ? settings->bools.video_dingux_ipu_keep_aspect : true;
bool ipu_integer_scaling = (settings) ? settings->bools.video_scale_integer : false;
if (!vid || !settings)
return;
/* Update 'keep aspect ratio' state, if required */
if (vid->keep_aspect != ipu_keep_aspect)
{
dingux_ipu_set_aspect_ratio_enable(ipu_keep_aspect);
vid->keep_aspect = ipu_keep_aspect;
}
/* Update integer scaling state, if required */
if (vid->integer_scaling != ipu_integer_scaling)
{
dingux_ipu_set_integer_scaling_enable(ipu_integer_scaling);
vid->integer_scaling = ipu_integer_scaling;
}
}
static uint32_t sdl_dingux_get_flags(void *data)
{
return 0;
}
static const video_poke_interface_t sdl_dingux_poke_interface = {
sdl_dingux_get_flags,
NULL,
NULL,
NULL,
NULL, /* get_refresh_rate */
sdl_dingux_set_filtering,
NULL, /* get_video_output_size */
NULL, /* get_video_output_prev */
NULL, /* get_video_output_next */
NULL, /* get_current_framebuffer */
NULL, /* get_proc_address */
NULL,
sdl_dingux_apply_state_changes,
sdl_dingux_set_texture_frame,
sdl_dingux_set_texture_enable,
NULL,
NULL, /* sdl_show_mouse */
NULL, /* sdl_grab_mouse_toggle */
NULL, /* get_current_shader */
NULL, /* get_current_software_framebuffer */
NULL /* get_hw_render_interface */
};
static void sdl_dingux_get_poke_interface(void *data, const video_poke_interface_t **iface)
{
*iface = &sdl_dingux_poke_interface;
}
static bool sdl_dingux_gfx_set_shader(void *data,
enum rarch_shader_type type, const char *path)
{
return false;
}
video_driver_t video_sdl_dingux = {
sdl_dingux_gfx_init,
sdl_dingux_gfx_frame,
sdl_dingux_gfx_set_nonblock_state,
sdl_dingux_gfx_alive,
sdl_dingux_gfx_focus,
sdl_dingux_gfx_suppress_screensaver,
sdl_dingux_gfx_has_windowed,
sdl_dingux_gfx_set_shader,
sdl_dingux_gfx_free,
"sdl_dingux",
NULL,
NULL, /* set_rotation */
sdl_dingux_gfx_viewport_info,
NULL, /* read_viewport */
NULL, /* read_frame_raw */
#ifdef HAVE_OVERLAY
NULL,
#endif
#ifdef HAVE_VIDEO_LAYOUT
NULL,
#endif
sdl_dingux_get_poke_interface
};