Retro/pcem
Watch
1
0
Fork
You've already forked pcem
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added video 'Alternative update-lock' option that may help performance on some machines. Patch from bit.

Browse source
This commit is contained in:
SarahW 2017-08-21 19:25:50 +01:00
commit 5d1b2e4f83
8 changed files with 1516 additions and 1491 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/pc.xrc
View file

@ -205,6 +205,10 @@
<label>_Dim display on lost focus</label>
<checkable>1</checkable>
</object>
<object class="wxMenuItem" name="IDM_VID_ALTERNATIVE_UPDATE_LOCK">
<label>Alternative update-lock</label>
<checkable>1</checkable>
</object>
<object class="separator"/>
<object class="wxMenu">
<label>Scale filtering</label>

1
src/wx-display.h
View file

@ -21,6 +21,7 @@ extern int video_scale_mode;
extern int video_vsync;
extern int video_focus_dim;
extern int video_fullscreen_mode;
extern int video_alternative_update_lock;
extern int win_doresize;

2636
src/wx-resources.cpp
View file

File diff suppressed because it is too large Load diff

18
src/wx-sdl2-video-gl3.c
View file

@ -762,7 +762,7 @@ static void read_shader_config()
}
}
int gl3_init(SDL_Window* window, sdl_render_driver requested_render_driver, BITMAP* screen)
int gl3_init(SDL_Window* window, sdl_render_driver requested_render_driver, SDL_Rect screen)
{
int i, j;
@ -801,9 +801,9 @@ int gl3_init(SDL_Window* window, sdl_render_driver requested_render_driver, BITM
glEnable(GL_TEXTURE_2D);
scene_texture.data = screen->dat;
scene_texture.width = screen->w;
scene_texture.height = screen->h;
scene_texture.data = NULL;
scene_texture.width = screen.w;
scene_texture.height = screen.h;
scene_texture.internal_format = GL_RGBA8;
scene_texture.format = GL_RGBA;
scene_texture.type = GL_UNSIGNED_INT_8_8_8_8_REV;
@ -1209,7 +1209,7 @@ static void render_pass(struct render_data* data)
glw->glUseProgram(0);
}
void gl3_present(SDL_Window* window, SDL_Rect video_rect, SDL_Rect window_rect, BITMAP* screen)
void gl3_present(SDL_Window* window, SDL_Rect video_rect, SDL_Rect window_rect, SDL_Rect screen)
{
if (!context)
return;
@ -1265,10 +1265,10 @@ void gl3_present(SDL_Window* window, SDL_Rect video_rect, SDL_Rect window_rect,
pass->state.tex_coords[7] = maxy;
// create input tex coords
minx = video_rect.x/(float)screen->w;
miny = video_rect.y/(float)screen->h;
maxx = (video_rect.x+video_rect.w)/(float)screen->w;
maxy = (video_rect.y+video_rect.h)/(float)screen->h;
minx = video_rect.x/(float)screen.w;
miny = video_rect.y/(float)screen.h;
maxx = (video_rect.x+video_rect.w)/(float)screen.w;
maxy = (video_rect.y+video_rect.h)/(float)screen.h;
GLfloat tex_coords[] = {
minx, miny,

360
src/wx-sdl2-video-renderer.c
View file

@ -1,180 +1,180 @@
#include <SDL2/SDL.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include "video.h"
#include "wx-utils.h"
#include "wx-sdl2-video.h"
#include "wx-sdl2-video-renderer.h"
static SDL_Texture* texture = NULL;
static SDL_Renderer* renderer = NULL;
extern int video_scale_mode;
extern int video_vsync;
extern int video_focus_dim;
extern int take_screenshot;
extern void screenshot_taken(unsigned char* rgb, int width, int height);
int sdl_video_renderer_init(SDL_Window* window, sdl_render_driver requested_render_driver, BITMAP* screen)
{
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, video_scale_mode ? "1" : "0");
const char* driver = requested_render_driver.sdl_id;
if (!driver) driver = "0";
SDL_SetHint(SDL_HINT_RENDER_DRIVER, driver);
int flags = SDL_RENDERER_ACCELERATED;
if (video_vsync) {
flags |= SDL_RENDERER_PRESENTVSYNC;
}
renderer = SDL_CreateRenderer(window, -1, flags);
if (!renderer)
{
char message[200];
sprintf(message,
"SDL window could not be created! Error: %s\n",
SDL_GetError());
wx_messagebox(0, message, "SDL Error", WX_MB_OK);
return SDL_FALSE;
}
SDL_RendererInfo rendererInfo;
SDL_GetRendererInfo(renderer, &rendererInfo);
sdl_render_driver* d = sdl_get_render_driver_by_name_ptr(rendererInfo.name);
if (!d)
strcpy(current_render_driver_name, "Unknown");
else
strcpy(current_render_driver_name, d->name);
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
screen->w, screen->h);
return SDL_TRUE;
}
void sdl_video_renderer_close()
{
if (texture)
{
SDL_DestroyTexture(texture);
texture = NULL;
}
if (renderer)
{
SDL_DestroyRenderer(renderer);
renderer = NULL;
}
}
void sdl_video_renderer_update(SDL_Window* window, SDL_Rect updated_rect, BITMAP* screen)
{
SDL_UpdateTexture(texture, &updated_rect, &((uint32_t*) screen->dat)[updated_rect.y * screen->w + updated_rect.x], screen->w * 4);
}
void sdl_video_renderer_present(SDL_Window* window, SDL_Rect texture_rect, SDL_Rect window_rect, BITMAP* screen)
{
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, &texture_rect, &window_rect);
int sshot = take_screenshot;
if (!sshot)
{
if (video_focus_dim && !(SDL_GetWindowFlags(window)&SDL_WINDOW_INPUT_FOCUS)) {
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0x80);
SDL_RenderFillRect(renderer, NULL);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xff);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
}
if (flash.enabled)
{
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, flash.color[0], flash.color[1], flash.color[2], flash.color[3]);
SDL_RenderFillRect(renderer, NULL);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xff);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
}
}
SDL_RenderPresent(renderer);
if (sshot)
{
take_screenshot = 0;
int width = window_rect.w;
int height = window_rect.h;
SDL_GetWindowSize(window, &width, &height);
/* seems to work without rendering to texture first */
// SDL_Texture* tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_TARGET, width, height);
//
// SDL_SetRenderTarget(renderer, tex);
// SDL_RenderClear(renderer);
// SDL_RenderCopy(renderer, texture, &texture_rect, &window_rect);
// SDL_RenderPresent(renderer);
unsigned char* rgba = (unsigned char*)malloc(width*height*4);
int res = SDL_RenderReadPixels(renderer, NULL, SDL_PIXELFORMAT_ABGR8888, rgba, width*4);
// SDL_SetRenderTarget(renderer, NULL);
// SDL_DestroyTexture(tex);
if (!res)
{
int x, y;
unsigned char* rgb = (unsigned char*)malloc(width*height*3);
for (x = 0; x < width; ++x)
{
for (y = 0; y < height; ++y)
{
rgb[(y*width+x)*3+0] = rgba[(y*width+x)*4+0];
rgb[(y*width+x)*3+1] = rgba[(y*width+x)*4+1];
rgb[(y*width+x)*3+2] = rgba[(y*width+x)*4+2];
}
}
screenshot_taken(rgb, width, height);
free(rgb);
}
else
screenshot_taken(0, 0, 0);
free(rgba);
}
}
sdl_renderer_t* sdl2_renderer_create()
{
sdl_renderer_t* renderer = malloc(sizeof(sdl_renderer_t));
renderer->init = sdl_video_renderer_init;
renderer->close = sdl_video_renderer_close;
renderer->update = sdl_video_renderer_update;
renderer->present = sdl_video_renderer_present;
renderer->always_update = 0;
return renderer;
}
void sdl2_renderer_close(sdl_renderer_t* renderer)
{
free(renderer);
}
int sdl2_renderer_available(struct sdl_render_driver* driver)
{
int i;
SDL_RendererInfo renderInfo;
for (i = 0; i < SDL_GetNumRenderDrivers(); ++i)
{
SDL_GetRenderDriverInfo(i, &renderInfo);
if (!strcmp(driver->sdl_id, renderInfo.name))
return 1;
}
return 0;
}
#include <SDL2/SDL.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include "video.h"
#include "wx-utils.h"
#include "wx-sdl2-video.h"
#include "wx-sdl2-video-renderer.h"
static SDL_Texture* texture = NULL;
static SDL_Renderer* renderer = NULL;
extern int video_scale_mode;
extern int video_vsync;
extern int video_focus_dim;
extern int take_screenshot;
extern void screenshot_taken(unsigned char* rgb, int width, int height);
int sdl_video_renderer_init(SDL_Window* window, sdl_render_driver requested_render_driver, SDL_Rect screen)
{
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, video_scale_mode ? "1" : "0");
const char* driver = requested_render_driver.sdl_id;
if (!driver) driver = "0";
SDL_SetHint(SDL_HINT_RENDER_DRIVER, driver);
int flags = SDL_RENDERER_ACCELERATED;
if (video_vsync) {
flags |= SDL_RENDERER_PRESENTVSYNC;
}
renderer = SDL_CreateRenderer(window, -1, flags);
if (!renderer)
{
char message[200];
sprintf(message,
"SDL window could not be created! Error: %s\n",
SDL_GetError());
wx_messagebox(0, message, "SDL Error", WX_MB_OK);
return SDL_FALSE;
}
SDL_RendererInfo rendererInfo;
SDL_GetRendererInfo(renderer, &rendererInfo);
sdl_render_driver* d = sdl_get_render_driver_by_name_ptr(rendererInfo.name);
if (!d)
strcpy(current_render_driver_name, "Unknown");
else
strcpy(current_render_driver_name, d->name);
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
screen.w, screen.h);
return SDL_TRUE;
}
void sdl_video_renderer_close()
{
if (texture)
{
SDL_DestroyTexture(texture);
texture = NULL;
}
if (renderer)
{
SDL_DestroyRenderer(renderer);
renderer = NULL;
}
}
void sdl_video_renderer_update(SDL_Window* window, SDL_Rect updated_rect, BITMAP* screen)
{
SDL_UpdateTexture(texture, &updated_rect, &((uint32_t*) screen->dat)[updated_rect.y * screen->w + updated_rect.x], screen->w * 4);
}
void sdl_video_renderer_present(SDL_Window* window, SDL_Rect texture_rect, SDL_Rect window_rect, SDL_Rect screen)
{
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, &texture_rect, &window_rect);
int sshot = take_screenshot;
if (!sshot)
{
if (video_focus_dim && !(SDL_GetWindowFlags(window)&SDL_WINDOW_INPUT_FOCUS)) {
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0x80);
SDL_RenderFillRect(renderer, NULL);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xff);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
}
if (flash.enabled)
{
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, flash.color[0], flash.color[1], flash.color[2], flash.color[3]);
SDL_RenderFillRect(renderer, NULL);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xff);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
}
}
SDL_RenderPresent(renderer);
if (sshot)
{
take_screenshot = 0;
int width = window_rect.w;
int height = window_rect.h;
SDL_GetWindowSize(window, &width, &height);
/* seems to work without rendering to texture first */
// SDL_Texture* tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_TARGET, width, height);
//
// SDL_SetRenderTarget(renderer, tex);
// SDL_RenderClear(renderer);
// SDL_RenderCopy(renderer, texture, &texture_rect, &window_rect);
// SDL_RenderPresent(renderer);
unsigned char* rgba = (unsigned char*)malloc(width*height*4);
int res = SDL_RenderReadPixels(renderer, NULL, SDL_PIXELFORMAT_ABGR8888, rgba, width*4);
// SDL_SetRenderTarget(renderer, NULL);
// SDL_DestroyTexture(tex);
if (!res)
{
int x, y;
unsigned char* rgb = (unsigned char*)malloc(width*height*3);
for (x = 0; x < width; ++x)
{
for (y = 0; y < height; ++y)
{
rgb[(y*width+x)*3+0] = rgba[(y*width+x)*4+0];
rgb[(y*width+x)*3+1] = rgba[(y*width+x)*4+1];
rgb[(y*width+x)*3+2] = rgba[(y*width+x)*4+2];
}
}
screenshot_taken(rgb, width, height);
free(rgb);
}
else
screenshot_taken(0, 0, 0);
free(rgba);
}
}
sdl_renderer_t* sdl2_renderer_create()
{
sdl_renderer_t* renderer = malloc(sizeof(sdl_renderer_t));
renderer->init = sdl_video_renderer_init;
renderer->close = sdl_video_renderer_close;
renderer->update = sdl_video_renderer_update;
renderer->present = sdl_video_renderer_present;
renderer->always_update = 0;
return renderer;
}
void sdl2_renderer_close(sdl_renderer_t* renderer)
{
free(renderer);
}
int sdl2_renderer_available(struct sdl_render_driver* driver)
{
int i;
SDL_RendererInfo renderInfo;
for (i = 0; i < SDL_GetNumRenderDrivers(); ++i)
{
SDL_GetRenderDriverInfo(i, &renderInfo);
if (!strcmp(driver->sdl_id, renderInfo.name))
return 1;
}
return 0;
}

64
src/wx-sdl2-video.c
View file

@ -12,17 +12,16 @@
void video_blit_complete();
static BITMAP *buffer32_vscale;
BITMAP *screen;
SDL_Rect old_screen_rect;
SDL_Rect screen_rect;
SDL_Rect updated_rect;
SDL_Rect window_rect;
SDL_Rect blit_rect;
SDL_Rect texture_rect;
int updated = 0;
static BITMAP *screen_copy = NULL;
static SDL_Rect screen_rect;
static SDL_Rect updated_rect;
static SDL_Rect updated_rect_copy;
static SDL_Rect blit_rect;
static SDL_Rect texture_rect;
static int updated = 0;
SDL_mutex* blitMutex = NULL;
static SDL_mutex* blitMutex = NULL;
static void sdl_blit_memtoscreen(int x, int y, int y1, int y2, int w, int h);
@ -30,6 +29,7 @@ int video_scale_mode = 1;
int video_vsync = 0;
int video_focus_dim = 0;
int video_fullscreen_mode = 0;
int video_alternative_update_lock = 0;
static sdl_render_driver sdl_render_drivers[] = {
{ RENDERER_AUTO, "auto", "Auto", 0, sdl2_renderer_create, sdl2_renderer_close, sdl2_renderer_available },
@ -55,22 +55,6 @@ void hline(BITMAP *b, int x1, int y, int x2, int col)
((uint32_t *)b->line[y])[x1] = col;
}
void blit(BITMAP *src, BITMAP *dst, int x1, int y1, int x2, int y2, int xs, int ys)
{
}
void stretch_blit(BITMAP *src, BITMAP *dst, int x1, int y1, int xs1, int ys1, int x2, int y2, int xs2, int ys2)
{
}
void rectfill(BITMAP *b, int x1, int y1, int x2, int y2, uint32_t col)
{
}
void set_palette(PALETTE p)
{
}
void destroy_bitmap(BITMAP *b)
{
free(b);
@ -254,8 +238,9 @@ int sdl_video_init()
video_blit_memtoscreen_func = sdl_blit_memtoscreen;
requested_render_driver = sdl_get_render_driver_by_id(RENDERER_AUTO, RENDERER_AUTO);
buffer32_vscale = create_bitmap(2048, 2048);
screen = create_bitmap(2048, 2048);
screen_rect.w = screen_rect.h = 2048;
screen = create_bitmap(screen_rect.w, screen_rect.h);
return SDL_TRUE;
}
@ -264,15 +249,20 @@ void sdl_video_close()
{
requested_render_driver.renderer_close(renderer);
renderer = NULL;
destroy_bitmap(buffer32_vscale);
destroy_bitmap(screen);
screen = NULL;
SDL_DestroyMutex(blitMutex);
}
int sdl_renderer_init(SDL_Window* window)
{
if (video_alternative_update_lock)
screen_copy = create_bitmap(screen_rect.w, screen_rect.h);
else
screen_copy = NULL;
renderer = requested_render_driver.renderer_create();
return renderer->init(window, requested_render_driver, screen);
return renderer->init(window, requested_render_driver, screen_rect);
}
void sdl_renderer_close()
@ -280,6 +270,10 @@ void sdl_renderer_close()
if (renderer)
renderer->close();
renderer = NULL;
if (screen_copy)
destroy_bitmap(screen_copy);
screen_copy = NULL;
}
int sdl_renderer_update(SDL_Window* window)
@ -289,12 +283,20 @@ int sdl_renderer_update(SDL_Window* window)
if (updated)
{
updated = 0;
renderer->update(window, updated_rect, screen);
if (screen_copy)
{
memcpy(&updated_rect_copy, &updated_rect, sizeof(updated_rect));
memcpy(screen_copy->dat + (updated_rect.y * screen_copy->w * 4), screen->dat + (updated_rect.y * screen->w * 4), updated_rect.h * screen->w * 4);
}
else
renderer->update(window, updated_rect, screen);
texture_rect.w = blit_rect.w;
texture_rect.h = blit_rect.h;
render = 1;
}
SDL_UnlockMutex(blitMutex);
if (screen_copy && render)
renderer->update(window, updated_rect_copy, screen_copy);
return render || renderer->always_update;
}
@ -312,7 +314,7 @@ void sdl_renderer_present(SDL_Window* window)
SDL_Rect wr;
SDL_GetWindowSize(window, &wr.w, &wr.h);
sdl_scale(video_fullscreen_scale, wr, &wr, texture_rect.w, texture_rect.h);
renderer->present(window, texture_rect, wr, screen);
renderer->present(window, texture_rect, wr, screen_rect);
}

4
src/wx-sdl2-video.h
View file

@ -9,10 +9,10 @@
struct sdl_render_driver;
typedef struct sdl_renderer_t {
int (*init)(SDL_Window* window, struct sdl_render_driver driver, BITMAP* screen);
int (*init)(SDL_Window* window, struct sdl_render_driver driver, SDL_Rect screen);
void (*close)();
void (*update)(SDL_Window* window, SDL_Rect updated_rect, BITMAP* screen);
void (*present)(SDL_Window* window, SDL_Rect texture_rect, SDL_Rect window_rect, BITMAP* screen);
void (*present)(SDL_Window* window, SDL_Rect texture_rect, SDL_Rect window_rect, SDL_Rect screen);
int always_update;
} sdl_renderer_t;

10
src/wx-sdl2.c
View file

@ -289,6 +289,7 @@ void sdl_loadconfig()
video_scale_mode = config_get_int(CFG_MACHINE, "SDL2", "scale_mode", video_scale_mode);
video_vsync = config_get_int(CFG_MACHINE, "SDL2", "vsync", video_vsync);
video_focus_dim = config_get_int(CFG_MACHINE, "SDL2", "focus_dim", video_focus_dim);
video_alternative_update_lock = config_get_int(CFG_MACHINE, "SDL2", "alternative_update_lock", video_alternative_update_lock);
requested_render_driver = sdl_get_render_driver_by_name(config_get_string(CFG_MACHINE, "SDL2", "render_driver", ""), RENDERER_SOFTWARE);
gl3_input_scale = config_get_float(CFG_MACHINE, "GL3", "input_scale", gl3_input_scale);
@ -325,6 +326,7 @@ void sdl_saveconfig()
config_set_int(CFG_MACHINE, "SDL2", "scale_mode", video_scale_mode);
config_set_int(CFG_MACHINE, "SDL2", "vsync", video_vsync);
config_set_int(CFG_MACHINE, "SDL2", "focus_dim", video_focus_dim);
config_set_int(CFG_MACHINE, "SDL2", "alternative_update_lock", video_alternative_update_lock);
config_set_string(CFG_MACHINE, "SDL2", "render_driver", (char*)requested_render_driver.sdl_id);
config_set_float(CFG_MACHINE, "GL3", "input_scale", gl3_input_scale);
@ -413,6 +415,7 @@ int wx_setupmenu(void* data)
wx_checkmenuitem(menu, WX_ID(menuitem), WX_MB_CHECKED);
wx_checkmenuitem(menu, WX_ID("IDM_VID_VSYNC"), video_vsync);
wx_checkmenuitem(menu, WX_ID("IDM_VID_LOST_FOCUS_DIM"), video_focus_dim);
wx_checkmenuitem(menu, WX_ID("IDM_VID_ALTERNATIVE_UPDATE_LOCK"), video_alternative_update_lock);
int format = 0;
if (!strcmp(screenshot_format, IMAGE_TIFF))
@ -973,6 +976,13 @@ int wx_handle_command(void* hwnd, int wParam, int checked)
wx_checkmenuitem(menu, wParam, video_focus_dim);
saveconfig(NULL);
}
else if (ID_IS("IDM_VID_ALTERNATIVE_UPDATE_LOCK"))
{
video_alternative_update_lock = !video_alternative_update_lock;
wx_checkmenuitem(menu, wParam, video_alternative_update_lock);
renderer_doreset = 1;
saveconfig(NULL);
}
else if (ID_RANGE("IDM_VID_GL3_INPUT_STRETCH[start]", "IDM_VID_GL3_INPUT_STRETCH[end]"))
{
gl3_input_stretch = wParam - wx_xrcid("IDM_VID_GL3_INPUT_STRETCH[start]");