static bool sunxi_gfx_frame(void *data, const void *frame, unsigned width,
unsigned height, unsigned pitch, const char *msg)
{
struct sunxi_video *_dispvars = (struct sunxi_video*)data;
if (_dispvars->src_width != width || _dispvars->src_height != height)
{
/* Sanity check on new dimensions */
if (width == 0 || height == 0)
return true;
RARCH_LOG("video_sunxi: internal resolution changed by core: %ux%u -> %ux%u\n",
_dispvars->src_width, _dispvars->src_height, width, height);
sunxi_setup_scale(_dispvars, width, height, pitch);
}
if (_dispvars->menu_active)
{
char buf[128] = {0};
video_monitor_get_fps(buf, sizeof(buf), NULL, 0);
ioctl(_dispvars->sunxi_disp->fd_fb, FBIO_WAITFORVSYNC, 0);
return true;
}
sunxi_update_main(frame, _dispvars);
_dispvars->frame_count++;
return true;
}
static bool dispmanx_gfx_frame(void *data, const void *frame, unsigned width,
unsigned height, unsigned pitch, const char *msg)
{
struct dispmanx_video *_dispvars = data;
if (width != _dispvars->surfaces[MAIN_SURFACE].width || height != _dispvars->surfaces[MAIN_SURFACE].height)
{
/* Sanity check. */
if (width == 0 || height == 0)
return true;
if (_dispvars->surfaces[MAIN_SURFACE].setup)
dispmanx_surface_free(_dispvars, &_dispvars->surfaces[MAIN_SURFACE]);
float aspect = video_driver_get_aspect_ratio();
/* Reconfiguring internal dimensions of the main surface is needed. */
dispmanx_surface_setup(_dispvars, width, height, pitch, aspect, &_dispvars->surfaces[MAIN_SURFACE]);
}
if (_dispvars->menu_active)
{
char buf[128];
video_monitor_get_fps(buf, sizeof(buf), NULL, 0);
}
/* Update main surface: locate free page, blit and flip. */
dispmanx_surface_update(_dispvars, frame, &_dispvars->surfaces[MAIN_SURFACE]);
_dispvars->frame_count++;
return true;
}
static void gfx_ctx_d3d_update_title(void *data)
{
char buf[128] = {0};
char buffer_fps[128] = {0};
settings_t *settings = config_get_ptr();
if (video_monitor_get_fps(buf, sizeof(buf),
buffer_fps, sizeof(buffer_fps)))
{
#ifndef _XBOX
d3d_video_t *d3d = (d3d_video_t*)data;
SetWindowText(g_hwnd, buf);
#endif
}
if (settings->fps_show)
{
#ifdef _XBOX
MEMORYSTATUS stat;
char mem[128] = {0};
GlobalMemoryStatus(&stat);
snprintf(mem, sizeof(mem), "|| MEM: %.2f/%.2fMB",
stat.dwAvailPhys/(1024.0f*1024.0f), stat.dwTotalPhys/(1024.0f*1024.0f));
strlcat(buffer_fps, mem, sizeof(buffer_fps));
#endif
rarch_main_msg_queue_push(buffer_fps, 1, 1, false);
}
}
static void android_gfx_ctx_update_window_title(void *data)
{
char buf[128], buf_fps[128];
settings_t *settings = config_get_ptr();
video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps));
if (settings->fps_show)
rarch_main_msg_queue_push(buf_fps, 1, 1, false);
}
static void gfx_ctx_xegl_update_window_title(void *data)
{
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show || g_settings.fps_monitor_enable;
(void)data;
if (video_monitor_get_fps(buf, sizeof(buf),
g_settings.fps_show ? buf_fps : NULL, sizeof(buf_fps)))
XStoreName(g_dpy, g_win, buf);
if (g_settings.fps_show)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_qnx_update_window_title(void *data)
{
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
(void)data;
video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps));
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
}
static void gfx_ctx_opendingux_update_window_title(void *data)
{
char buf[128];
char buf_fps[128];
settings_t *settings = config_get_ptr();
buf[0] = buf_fps[0] = '\0';
video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps));
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
}
static void gfx_ctx_glx_update_window_title(void *data)
{
char buf[128], buf_fps[128];
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
XStoreName(glx->g_dpy, glx->g_win, buf);
if (settings->fps_show)
rarch_main_msg_queue_push(buf_fps, 1, 1, false);
}
static void gfx_ctx_ps3_update_window_title(void *data)
{
(void)data;
char buf[128], buf_fps[128];
bool fps_draw = g_settings.fps_show || g_settings.fps_monitor_enable;
if (!fps_draw)
return;
video_monitor_get_fps(buf, sizeof(buf),
g_settings.fps_show ? buf_fps : NULL, sizeof(buf_fps));
if (g_settings.fps_show)
msg_queue_push(g_extern.msg_queue, buf_fps, 1, 1);
}
static void gfx_ctx_wl_update_window_title(void *data)
{
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
wl_shell_surface_set_title(wl->shell_surf, buf);
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
}
static void gfx_ctx_xegl_update_window_title(void *data)
{
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
(void)data;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
XStoreName(g_dpy, g_win, buf);
if (settings->fps_show)
rarch_main_msg_queue_push(buf_fps, 1, 1, false);
}
static void osmesa_ctx_update_window_title(void *data)
{
static char buf[128] = {0};
static char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
gfx_ctx_osmesa_data_t *osmesa = (gfx_ctx_osmesa_data_t*)data;
if (!osmesa)
return;
video_monitor_get_fps(buf, sizeof(buf), buf_fps, sizeof(buf_fps));
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
}
static void gfx_ctx_wgl_update_window_title(void *data)
{
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
HWND window = win32_get_window();
(void)data;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
SetWindowText(window, buf);
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
}
static bool sdl2_gfx_frame(void *data, const void *frame, unsigned width,
unsigned height, unsigned pitch, const char *msg)
{
char buf[128];
sdl2_video_t *vid = (sdl2_video_t*)data;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (vid->should_resize)
sdl_refresh_viewport(vid);
if (frame)
{
sdl_refresh_input_size(vid, false, vid->video.rgb32, width, height, pitch);
RARCH_PERFORMANCE_INIT(sdl_copy_frame);
RARCH_PERFORMANCE_START(sdl_copy_frame);
SDL_UpdateTexture(vid->frame.tex, NULL, frame, pitch);
RARCH_PERFORMANCE_STOP(sdl_copy_frame);
}
SDL_RenderCopyEx(vid->renderer, vid->frame.tex, NULL, NULL, vid->rotation, NULL, SDL_FLIP_NONE);
#ifdef HAVE_MENU
if (runloop->is_menu)
menu_driver_frame();
#endif
if (vid->menu.active)
SDL_RenderCopy(vid->renderer, vid->menu.tex, NULL, NULL);
if (msg)
sdl2_render_msg(vid, msg);
SDL_RenderPresent(vid->renderer);
if (video_monitor_get_fps(buf, sizeof(buf), NULL, 0))
SDL_SetWindowTitle(vid->window, buf);
vid->frame_count++;
return true;
}
static bool drm_gfx_frame(void *data, const void *frame, unsigned width,
unsigned height, uint64_t frame_count, unsigned pitch, const char *msg)
{
struct drm_video *_drmvars = data;
if (width != _drmvars->core_width || height != _drmvars->core_height)
{
/* Sanity check. */
if (width == 0 || height == 0)
return true;
_drmvars->core_width = width;
_drmvars->core_height = height;
_drmvars->core_pitch = pitch;
if (_drmvars->main_surface != NULL)
drm_surface_free(_drmvars, &_drmvars->main_surface);
/* We need to recreate the main surface and it's pages (buffers). */
drm_surface_setup(_drmvars,
width,
height,
pitch,
_drmvars->rgb32 ? 4 : 2,
_drmvars->rgb32 ? DRM_FORMAT_XRGB8888 : DRM_FORMAT_RGB565,
255,
_drmvars->current_aspect,
3,
0,
&_drmvars->main_surface);
/* We need to change the plane to read from the main surface */
drm_plane_setup(_drmvars->main_surface);
}
if (_drmvars->menu_active)
{
char buf[128];
video_monitor_get_fps(buf, sizeof(buf), NULL, 0);
}
/* Update main surface: locate free page, blit and flip. */
drm_surface_update(_drmvars, frame, _drmvars->main_surface);
return true;
}
static bool dispmanx_gfx_frame(void *data, const void *frame, unsigned width,
unsigned height, unsigned pitch, const char *msg)
{
struct dispmanx_video *_dispvars = data;
/* Check if neither menu nor core framebuffer is to be displayed. */
if (!_dispvars->menu_active && !frame)
return true;
if (width != _dispvars->width || height != _dispvars->height)
{
/* Sanity check. */
if (width == 0 || height == 0)
return true;
RARCH_LOG("video_dispmanx: internal frame resolution changed by core\n");
if (!dispmanx_setup_scale(_dispvars, width, height, pitch))
{
RARCH_ERR("video_dispmanx: frame resolution set failed\n");
return false;
}
dispmanx_blank_console (_dispvars);
}
if (_dispvars->menu_active)
{
char buf[128];
video_monitor_get_fps(buf, sizeof(buf), NULL, 0);
/* Synchronous flipping of the menu buffers. */
_dispvars->update = vc_dispmanx_update_start(0);
vc_dispmanx_element_change_source(_dispvars->update, _dispvars->menu_element,
_dispvars->menu_resources[_dispvars->menu_flip_page]);
vc_dispmanx_update_submit_sync(_dispvars->update);
return true;
}
/* Update main game screen: locate free page, blit and flip. */
dispmanx_update_main(_dispvars, frame);
return true;
}
static void sdl_ctx_update_window_title(void *data)
{
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
if (!sdl)
return;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
{
#ifdef HAVE_SDL2
SDL_SetWindowTitle(sdl->g_win, buf);
#else
SDL_WM_SetCaption(buf, NULL);
#endif
}
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
}
static bool psp_frame(void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch, const char *msg)
{
static char fps_txt[128], fps_text_buf[128];
psp1_video_t *psp = (psp1_video_t*)data;
#ifdef DISPLAY_FPS
static uint64_t currentTick,lastTick;
static float fps=0.0;
static int frames;
#endif
if (!width || !height)
return false;
if (((uint32_t)frame&0x04000000) || (frame == RETRO_HW_FRAME_BUFFER_VALID))
psp->hw_render = true;
else if (frame)
psp->hw_render = false;
if (!psp->hw_render)
sceGuSync(0, 0); /* let the core decide when to sync when HW_RENDER */
pspDebugScreenSetBase(psp->draw_buffer);
pspDebugScreenSetXY(0,0);
video_monitor_get_fps(fps_txt, sizeof(fps_txt),
g_settings.fps_show ? fps_text_buf : NULL,
g_settings.fps_show ? sizeof(fps_text_buf) : 0);
if(g_settings.fps_show)
{
pspDebugScreenSetXY(68 - strlen(fps_text_buf) - 1,0);
pspDebugScreenPuts(fps_text_buf);
pspDebugScreenSetXY(0,1);
}
if (msg)
pspDebugScreenPuts(msg);
if ((psp->vsync)&&(psp->vblank_not_reached))
sceDisplayWaitVblankStart();
psp->vblank_not_reached = true;
#ifdef DISPLAY_FPS
frames++;
sceRtcGetCurrentTick(¤tTick);
uint32_t diff = currentTick - lastTick;
if(diff > 1000000)
{
fps = (float)frames * 1000000.0 / diff;
lastTick = currentTick;
frames = 0;
}
pspDebugScreenSetXY(0,0);
pspDebugScreenPrintf("%f", fps);
#endif
psp->draw_buffer = FROM_GU_POINTER(sceGuSwapBuffers());
g_extern.frame_count++;
RARCH_PERFORMANCE_INIT(psp_frame_run);
RARCH_PERFORMANCE_START(psp_frame_run);
if (psp->should_resize)
psp_update_viewport(psp);
psp_set_tex_coords(psp->frame_coords, width, height);
sceGuStart(GU_DIRECT, psp->main_dList);
sceGuTexFilter(psp->tex_filter, psp->tex_filter);
sceGuClear(GU_COLOR_BUFFER_BIT);
/* frame in VRAM ? texture/palette was
* set in core so draw directly */
if (psp->hw_render)
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF |
GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL,
(void*)(psp->frame_coords));
else
{
if (frame)
{
sceKernelDcacheWritebackRange(frame,pitch * height);
sceGuCopyImage(GU_PSM_5650, ((u32)frame & 0xF) >> psp->bpp_log2,
0, width, height, pitch >> psp->bpp_log2,
(void*)((u32)frame & ~0xF), 0, 0, width, psp->texture);
}
sceGuTexImage(0, next_pow2(width), next_pow2(height), width, psp->texture);
sceGuCallList(psp->frame_dList);
}
sceGuFinish();
RARCH_PERFORMANCE_STOP(psp_frame_run);
if(psp->menu.active)
{
sceGuSendList(GU_TAIL, psp->menu.dList, &(psp->menu.context_storage));
sceGuSync(0, 0);
}
return true;
}
static bool d3d_construct(d3d_video_t *d3d,
const video_info_t *info, const input_driver_t **input,
void **input_data)
{
unsigned full_x, full_y;
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
d3d->should_resize = false;
#ifndef _XBOX
gfx_set_dwm();
#endif
#if defined(HAVE_MENU)
if (d3d->menu)
free(d3d->menu);
d3d->menu = (overlay_t*)calloc(1, sizeof(overlay_t));
if (!d3d->menu)
return false;
d3d->menu->tex_coords.x = 0;
d3d->menu->tex_coords.y = 0;
d3d->menu->tex_coords.w = 1;
d3d->menu->tex_coords.h = 1;
d3d->menu->vert_coords.x = 0;
d3d->menu->vert_coords.y = 1;
d3d->menu->vert_coords.w = 1;
d3d->menu->vert_coords.h = -1;
#endif
#if defined(HAVE_WINDOW) && !defined(_XBOX)
memset(&d3d->windowClass, 0, sizeof(d3d->windowClass));
d3d->windowClass.cbSize = sizeof(d3d->windowClass);
d3d->windowClass.style = CS_HREDRAW | CS_VREDRAW;
d3d->windowClass.lpfnWndProc = WindowProc;
d3d->windowClass.hInstance = NULL;
d3d->windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
d3d->windowClass.lpszClassName = "RetroArch";
d3d->windowClass.hIcon = LoadIcon(GetModuleHandle(NULL),
MAKEINTRESOURCE(IDI_ICON));
d3d->windowClass.hIconSm = (HICON)LoadImage(GetModuleHandle(NULL),
MAKEINTRESOURCE(IDI_ICON), IMAGE_ICON, 16, 16, 0);
if (!info->fullscreen)
d3d->windowClass.hbrBackground = (HBRUSH)COLOR_WINDOW;
RegisterClassEx(&d3d->windowClass);
#endif
#ifdef HAVE_MONITOR
RECT mon_rect = d3d_monitor_rect(d3d);
bool windowed_full = settings->video.windowed_fullscreen;
full_x = (windowed_full || info->width == 0) ?
(mon_rect.right - mon_rect.left) : info->width;
full_y = (windowed_full || info->height == 0) ?
(mon_rect.bottom - mon_rect.top) : info->height;
RARCH_LOG("[D3D]: Monitor size: %dx%d.\n",
(int)(mon_rect.right - mon_rect.left),
(int)(mon_rect.bottom - mon_rect.top));
#else
if (d3d->ctx_driver && d3d->ctx_driver->get_video_size)
d3d->ctx_driver->get_video_size(d3d, &full_x, &full_y);
#endif
d3d->screen_width = info->fullscreen ? full_x : info->width;
d3d->screen_height = info->fullscreen ? full_y : info->height;
#ifndef _XBOX
#ifdef HAVE_WINDOW
char buffer[128];
unsigned win_width = d3d->screen_width;
unsigned win_height = d3d->screen_height;
RECT rect = {0};
if (!info->fullscreen)
{
rect.right = d3d->screen_width;
rect.bottom = d3d->screen_height;
AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);
win_width = rect.right - rect.left;
win_height = rect.bottom - rect.top;
}
video_monitor_get_fps(buffer, sizeof(buffer), NULL, 0);
std::string title = buffer;
title += " || Direct3D";
d3d->hWnd = CreateWindowEx(0, "RetroArch", title.c_str(),
info->fullscreen ?
(WS_EX_TOPMOST | WS_POPUP) : WS_OVERLAPPEDWINDOW,
info->fullscreen ? mon_rect.left : CW_USEDEFAULT,
info->fullscreen ? mon_rect.top : CW_USEDEFAULT,
win_width, win_height,
NULL, NULL, NULL, d3d);
driver->display_type = RARCH_DISPLAY_WIN32;
driver->video_display = 0;
driver->video_window = (uintptr_t)d3d->hWnd;
#endif
#endif
if (d3d && d3d->ctx_driver && d3d->ctx_driver->show_mouse)
d3d->ctx_driver->show_mouse(d3d, !info->fullscreen
#ifdef HAVE_OVERLAY
|| d3d->overlays_enabled
#endif
);
#ifndef _XBOX
#ifdef HAVE_WINDOW
if (!info->fullscreen && settings->ui.menubar_enable)
{
RECT rc_temp = {0, 0, win_height, 0x7FFF};
SetMenu(d3d->hWnd, LoadMenu(GetModuleHandle(NULL),MAKEINTRESOURCE(IDR_MENU)));
SendMessage(d3d->hWnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rc_temp);
win_height += rc_temp.top + rect.top;
SetWindowPos(d3d->hWnd, NULL, 0, 0, win_width, win_height, SWP_NOMOVE);
}
ShowWindow(d3d->hWnd, SW_RESTORE);
UpdateWindow(d3d->hWnd);
SetForegroundWindow(d3d->hWnd);
SetFocus(d3d->hWnd);
#endif
#ifdef HAVE_SHADERS
/* This should only be done once here
* to avoid set_shader() to be overridden
* later. */
enum rarch_shader_type type =
video_shader_parse_type(settings->video.shader_path, RARCH_SHADER_NONE);
if (settings->video.shader_enable && type == RARCH_SHADER_CG)
d3d->shader_path = settings->video.shader_path;
if (!d3d_process_shader(d3d))
return false;
#endif
#endif
d3d->video_info = *info;
if (!d3d_initialize(d3d, &d3d->video_info))
return false;
if (input && input_data &&
d3d->ctx_driver && d3d->ctx_driver->input_driver)
d3d->ctx_driver->input_driver(d3d, input, input_data);
RARCH_LOG("[D3D]: Init complete.\n");
return true;
}
