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

src/pc.xrc

@@ -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>

src/wx-display.h

@@ -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;
 

src/wx-sdl2-video-gl3.c

@@ -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.data = NULL;
-        scene_texture.width = screen->w;
+        scene_texture.width = screen.w;
-        scene_texture.height = screen->h;
+        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;
+                minx = video_rect.x/(float)screen.w;
-                miny = video_rect.y/(float)screen->h;
+                miny = video_rect.y/(float)screen.h;
-                maxx = (video_rect.x+video_rect.w)/(float)screen->w;
+                maxx = (video_rect.x+video_rect.w)/(float)screen.w;
-                maxy = (video_rect.y+video_rect.h)/(float)screen->h;
+                maxy = (video_rect.y+video_rect.h)/(float)screen.h;
 
                 GLfloat tex_coords[] = {
                         minx, miny,

src/wx-sdl2-video-renderer.c

@@ -16,7 +16,7 @@ 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)
+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;
@@ -49,7 +49,7 @@ int sdl_video_renderer_init(SDL_Window* window, sdl_render_driver requested_rend
 
         texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
                         SDL_TEXTUREACCESS_STREAMING,
-                        screen->w, screen->h);
+                        screen.w, screen.h);
 
         return SDL_TRUE;
 
@@ -74,7 +74,7 @@ void sdl_video_renderer_update(SDL_Window* window, SDL_Rect updated_rect, BITMAP
         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)
+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);

src/wx-sdl2-video.c

@@ -12,17 +12,16 @@
 
 void video_blit_complete();
 
-static BITMAP *buffer32_vscale;
 BITMAP *screen;
-SDL_Rect old_screen_rect;
+static BITMAP *screen_copy = NULL;
-SDL_Rect screen_rect;
+static SDL_Rect screen_rect;
-SDL_Rect updated_rect;
+static SDL_Rect updated_rect;
-SDL_Rect window_rect;
+static SDL_Rect updated_rect_copy;
-SDL_Rect blit_rect;
+static SDL_Rect blit_rect;
-SDL_Rect texture_rect;
+static SDL_Rect texture_rect;
-int updated = 0;
+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_rect.w = screen_rect.h = 2048;
-        screen = create_bitmap(2048, 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);
 
 }
 

src/wx-sdl2-video.h

@@ -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;
 

src/wx-sdl2.c

@@ -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]");