chore: migrate from SDL2 to SDL3

[no changelog]

Author: M1nd3r

core/SConscript.bootloader_emu

@@ -228,9 +228,9 @@ except OSError:
     print("libjpeg not installed, Emulator build is not possible")
 
 try:
-    env.ParseConfig('pkg-config --cflags --libs sdl2 SDL2_image')
+    env.ParseConfig('pkg-config --cflags --libs sdl3 sdl3-image')
 except OSError:
-    print("SDL2 not installed, Emulator build is not possible")
+    print("SDL3 not installed, Emulator build is not possible")
 
 
 env.Replace(

core/SConscript.prodtest_emu

@@ -243,9 +243,9 @@ except OSError:
     print("libjpeg not installed, Emulator build is not possible")
 
 try:
-    env.ParseConfig('pkg-config --cflags --libs sdl2 SDL2_image')
+    env.ParseConfig('pkg-config --cflags --libs sdl3 sdl3-image')
 except OSError:
-    print("SDL2 not installed, Emulator build is not possible")
+    print("SDL3 not installed, Emulator build is not possible")
 
 
 env.Replace(

core/SConscript.unix

@@ -562,9 +562,9 @@ except OSError:
     print("libjpeg not installed, Emulator build is not possible")
 
 try:
-    env.ParseConfig('pkg-config --cflags --libs sdl2 SDL2_image')
+    env.ParseConfig('pkg-config --cflags --libs sdl3 sdl3-image')
 except OSError:
-    print("SDL2 not installed, Emulator build is not possible")
+    print("SDL3 not installed, Emulator build is not possible")
 
 BYTECODE_OPTIMIZATION = {'0': '0', '1': '3'}[PYOPT]
 
@@ -980,7 +980,8 @@ env.Depends(obj_program, qstr_generated)
 program = env.Command(
     target='trezor-emu-core',
     source=obj_program,
-    action='$CC -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $LINKFLAGS', )
+    action='$CC -o $TARGET $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $LINKFLAGS',
+)
 
 if CMAKELISTS != 0:
     env.Depends(program, cmake_gen)

core/embed/io/button/unix/button.c

@@ -79,7 +79,8 @@ void button_deinit(void) {
 static void button_sdl_event_filter(void* context, SDL_Event* sdl_event) {
   button_driver_t* drv = &g_button_driver;
 
-  if (sdl_event->type != SDL_KEYDOWN && sdl_event->type != SDL_KEYUP) {
+  if (sdl_event->type != SDL_EVENT_KEY_DOWN &&
+      sdl_event->type != SDL_EVENT_KEY_UP) {
     return;
   }
 
@@ -89,7 +90,7 @@ static void button_sdl_event_filter(void* context, SDL_Event* sdl_event) {
 
   button_t button;
 
-  switch (sdl_event->key.keysym.sym) {
+  switch (sdl_event->key.key) {
 #ifdef BTN_LEFT_KEY
     case BTN_LEFT_KEY:
       button = BTN_LEFT;
@@ -109,7 +110,7 @@ static void button_sdl_event_filter(void* context, SDL_Event* sdl_event) {
       return;
   }
 
-  if (sdl_event->type == SDL_KEYDOWN) {
+  if (sdl_event->type == SDL_EVENT_KEY_DOWN) {
     drv->state |= (1 << button);
   } else {
     drv->state &= ~(1 << button);

core/embed/io/display/unix/display_driver.c

@@ -30,10 +30,11 @@
 #include <sys/logging.h>
 #include <sys/systask.h>
 
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_blendmode.h>
-#include <SDL2/SDL_image.h>
-#include <SDL2/SDL_render.h>
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_blendmode.h>
+#include <SDL3/SDL_render.h>
+#include <SDL3_image/SDL_image.h>
+#include <stdlib.h>
 
 #include "profile.h"
 
@@ -109,7 +110,7 @@ bool display_init(display_content_mode_t mode) {
     return true;
   }
 
-  if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+  if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_HAPTIC | SDL_INIT_EVENTS)) {
     LOG_ERR("%s", SDL_GetError());
     error_shutdown("SDL_Init error");
   }
@@ -123,21 +124,19 @@ bool display_init(display_content_mode_t mode) {
     window_title_alloc = NULL;
   }
 
-  drv->window =
-      SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED,
-                       SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT,
+  drv->window = SDL_CreateWindow(window_title, WINDOW_WIDTH, WINDOW_HEIGHT,
 #ifdef TREZOR_EMULATOR_RASPI
-                       SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN
+                                 SDL_WINDOW_FULLSCREEN
 #else
-                       SDL_WINDOW_SHOWN
+                                 0  // windows are visible by default in SDL3
 #endif
-      );
+  );
   free(window_title_alloc);
   if (!drv->window) {
     LOG_ERR("%s", SDL_GetError());
     error_shutdown("SDL_CreateWindow error");
   }
-  drv->renderer = SDL_CreateRenderer(drv->window, -1, SDL_RENDERER_SOFTWARE);
+  drv->renderer = SDL_CreateRenderer(drv->window, NULL);
   if (!drv->renderer) {
     LOG_ERR("%s", SDL_GetError());
     SDL_DestroyWindow(drv->window);
@@ -146,9 +145,10 @@ bool display_init(display_content_mode_t mode) {
   SDL_SetRenderDrawColor(drv->renderer, 0, 0, 0, 255);
   SDL_RenderClear(drv->renderer);
 
-  drv->buffer = SDL_CreateRGBSurface(0, DISPLAY_RESX, DISPLAY_RESY, COLOR_DEPTH,
-                                     COLOR_MASK_R, COLOR_MASK_G, COLOR_MASK_B,
-                                     COLOR_MASK_A);
+  drv->buffer = SDL_CreateSurface(
+      DISPLAY_RESX, DISPLAY_RESY,
+      SDL_GetPixelFormatForMasks(COLOR_DEPTH, COLOR_MASK_R, COLOR_MASK_G,
+                                 COLOR_MASK_B, COLOR_MASK_A));
   drv->texture = SDL_CreateTexture(drv->renderer, PIXEL_FORMAT,
                                    SDL_TEXTUREACCESS_STREAMING, DISPLAY_RESX,
                                    DISPLAY_RESY);
@@ -162,31 +162,31 @@ bool display_init(display_content_mode_t mode) {
 #define CONCAT_LEN(name) CONCAT_LEN_HELPER(name)
 #ifdef BACKGROUND_FILE
 #include BACKGROUND_FILE
-  drv->background = IMG_LoadTexture_RW(
+  drv->background = IMG_LoadTexture_IO(
       drv->renderer,
-      SDL_RWFromMem(BACKGROUND_NAME, CONCAT_LEN(BACKGROUND_NAME)), 0);
+      SDL_IOFromMem(BACKGROUND_NAME, CONCAT_LEN(BACKGROUND_NAME)), true);
 #endif
 #ifdef FOREGROUND_FILE
 #include FOREGROUND_FILE
-  drv->foreground = IMG_LoadTexture_RW(
+  drv->foreground = IMG_LoadTexture_IO(
       drv->renderer,
-      SDL_RWFromMem(FOREGROUND_NAME, CONCAT_LEN(FOREGROUND_NAME)), 0);
+      SDL_IOFromMem(FOREGROUND_NAME, CONCAT_LEN(FOREGROUND_NAME)), true);
   if (drv->foreground) {
     SDL_SetTextureBlendMode(drv->foreground, SDL_BLENDMODE_BLEND);
     // check that foreground dimensions match the window size which is important
     // for cutouts
-    int fw, fh;
-    if (SDL_QueryTexture(drv->foreground, NULL, NULL, &fw, &fh) == 0) {
-      if (fw != WINDOW_WIDTH || fh != WINDOW_HEIGHT) {
+    float fw, fh;
+    if (SDL_GetTextureSize(drv->foreground, &fw, &fh)) {
+      if ((int)fw != WINDOW_WIDTH || (int)fh != WINDOW_HEIGHT) {
         LOG_ERR(
             "Foreground texture size (%dx%d) does not match window size "
             "(%dx%d)",
-            fw, fh, WINDOW_WIDTH, WINDOW_HEIGHT);
+            (int)fw, (int)fh, WINDOW_WIDTH, WINDOW_HEIGHT);
         error_shutdown("Foreground texture size mismatch");
       }
     } else {
-      LOG_ERR("SDL_QueryTexture failed: %s", SDL_GetError());
-      error_shutdown("SDL_QueryTexture error");
+      LOG_ERR("SDL_GetTextureSize failed: %s", SDL_GetError());
+      error_shutdown("SDL_GetTextureSize error");
     }
   }
 #endif
@@ -235,8 +235,8 @@ void display_deinit(display_content_mode_t mode) {
 
   gfx_bitblt_deinit();
 
-  SDL_FreeSurface(drv->prev_saved);
-  SDL_FreeSurface(drv->buffer);
+  SDL_DestroySurface(drv->prev_saved);
+  SDL_DestroySurface(drv->buffer);
   if (drv->background != NULL) {
     SDL_DestroyTexture(drv->background);
   }
@@ -416,22 +416,22 @@ void draw_rgb_led() {
   for (int y = -radius; y <= radius; y++) {
     for (int x = -radius; x <= radius; x++) {
       if (x * x + y * y <= radius * radius) {
-        SDL_RenderDrawPoint(drv->renderer, center_x + x, center_y + y);
+        SDL_RenderPoint(drv->renderer, center_x + x, center_y + y);
       }
     }
   }
   SDL_SetRenderDrawColor(drv->renderer, 0, 0, 0, 255);
 }
 #endif  // USE_RGB_LED
 
-static SDL_Rect screen_rect(void) {
+static SDL_FRect screen_rect(void) {
   display_driver_t *drv = &g_display_driver;
   if (drv->background || drv->foreground) {
-    return (SDL_Rect){TOUCH_OFFSET_X, TOUCH_OFFSET_Y, DISPLAY_RESX,
-                      DISPLAY_RESY};
+    return (SDL_FRect){TOUCH_OFFSET_X, TOUCH_OFFSET_Y, DISPLAY_RESX,
+                       DISPLAY_RESY};
   } else {
-    return (SDL_Rect){EMULATOR_BORDER, EMULATOR_BORDER, DISPLAY_RESX,
-                      DISPLAY_RESY};
+    return (SDL_FRect){EMULATOR_BORDER, EMULATOR_BORDER, DISPLAY_RESX,
+                       DISPLAY_RESY};
   }
 }
 
@@ -447,8 +447,8 @@ static void display_refresh_internal(void) {
 #endif
 
   if (drv->background) {
-    const SDL_Rect r = {0, 0, WINDOW_WIDTH, WINDOW_HEIGHT};
-    SDL_RenderCopy(drv->renderer, drv->background, NULL, &r);
+    const SDL_FRect r = {0, 0, WINDOW_WIDTH, WINDOW_HEIGHT};
+    SDL_RenderTexture(drv->renderer, drv->background, NULL, &r);
   } else {
     SDL_RenderClear(drv->renderer);
   }
@@ -458,13 +458,13 @@ static void display_refresh_internal(void) {
 #define BACKLIGHT_NORMAL 150
   SDL_SetTextureAlphaMod(
       drv->texture, MIN(255, 255 * drv->backlight_level / BACKLIGHT_NORMAL));
-  const SDL_Rect r = screen_rect();
-  SDL_RenderCopyEx(drv->renderer, drv->texture, NULL, &r,
-                   drv->orientation_angle, NULL, 0);
+  const SDL_FRect r = screen_rect();
+  SDL_RenderTextureRotated(drv->renderer, drv->texture, NULL, &r,
+                           drv->orientation_angle, NULL, 0);
 
   if (drv->foreground) {
-    const SDL_Rect fr = {0, 0, WINDOW_WIDTH, WINDOW_HEIGHT};
-    SDL_RenderCopy(drv->renderer, drv->foreground, NULL, &fr);
+    const SDL_FRect fr = {0, 0, WINDOW_WIDTH, WINDOW_HEIGHT};
+    SDL_RenderTexture(drv->renderer, drv->foreground, NULL, &fr);
   }
 
 #ifdef USE_RGB_LED
@@ -597,19 +597,20 @@ void display_save(const char *prefix) {
   static char filename[256];
   // take a cropped view of the screen contents
   const SDL_Rect rect = {0, 0, DISPLAY_RESX, DISPLAY_RESY};
-  SDL_Surface *crop = SDL_CreateRGBSurface(
-      drv->buffer->flags, rect.w, rect.h, drv->buffer->format->BitsPerPixel,
-      drv->buffer->format->Rmask, drv->buffer->format->Gmask,
-      drv->buffer->format->Bmask, drv->buffer->format->Amask);
+  SDL_Surface *crop = SDL_CreateSurface(rect.w, rect.h, drv->buffer->format);
+  if (crop == NULL) {
+    LOG_ERR("SDL_CreateSurface failed: %s", SDL_GetError());
+    return;
+  }
   SDL_BlitSurface(drv->buffer, &rect, crop, NULL);
   // compare with previous screen, skip if equal
   if (drv->prev_saved != NULL) {
     if (memcmp(drv->prev_saved->pixels, crop->pixels, crop->pitch * crop->h) ==
         0) {
-      SDL_FreeSurface(crop);
+      SDL_DestroySurface(crop);
       return;
     }
-    SDL_FreeSurface(drv->prev_saved);
+    SDL_DestroySurface(drv->prev_saved);
   }
   // save to png
   snprintf(filename, sizeof(filename), "%s%08d.png", prefix, count++);
@@ -624,7 +625,7 @@ void display_clear_save(void) {
     return;
   }
 
-  SDL_FreeSurface(drv->prev_saved);
+  SDL_DestroySurface(drv->prev_saved);
   drv->prev_saved = NULL;
 }
 
@@ -636,7 +637,7 @@ static void display_draw_suspend_overlay_internal(void) {
     return;
   }
 
-  SDL_Rect screen = screen_rect();
+  SDL_FRect screen = screen_rect();
   // create a blue texture
   SDL_Texture *overlay =
       SDL_CreateTexture(drv->renderer, SDL_PIXELFORMAT_RGBA8888,
@@ -649,24 +650,33 @@ static void display_draw_suspend_overlay_internal(void) {
   SDL_RenderClear(drv->renderer);
 
   // draw the suspend overlay png in the middle of the texture
-  SDL_Texture *suspend_text = IMG_LoadTexture_RW(
+  SDL_Texture *suspend_text = IMG_LoadTexture_IO(
       drv->renderer,
-      SDL_RWFromMem(_suspend_overlay_text_data, _suspend_overlay_text_len), 0);
-  int text_width, text_height;
-  SDL_QueryTexture(suspend_text, NULL, NULL, &text_width, &text_height);
-  SDL_Rect middle = {(screen.w - text_width) / 2, (screen.h - text_height) / 2,
-                     text_width, text_height};
-  SDL_RenderCopy(drv->renderer, suspend_text, NULL, &middle);
+      SDL_IOFromMem(_suspend_overlay_text_data, _suspend_overlay_text_len),
+      true);
+  if (suspend_text == NULL) {
+    LOG_ERR("Failed to load suspend overlay texture: %s", SDL_GetError());
+    goto cleanup;
+  }
+  float text_width = 0.0f, text_height = 0.0f;
+  if (!SDL_GetTextureSize(suspend_text, &text_width, &text_height)) {
+    LOG_ERR("SDL_GetTextureSize failed: %s", SDL_GetError());
+    goto cleanup;
+  }
+  SDL_FRect middle = {(screen.w - text_width) / 2, (screen.h - text_height) / 2,
+                      text_width, text_height};
+  SDL_RenderTexture(drv->renderer, suspend_text, NULL, &middle);
   SDL_RenderPresent(drv->renderer);
 
   // render to the screen
   SDL_SetRenderTarget(drv->renderer, NULL);
-  SDL_RenderCopy(drv->renderer, overlay, NULL, &screen);
+  SDL_RenderTexture(drv->renderer, overlay, NULL, &screen);
   SDL_RenderPresent(drv->renderer);
 
-  // cleanup
+cleanup:
   SDL_DestroyTexture(suspend_text);
   SDL_DestroyTexture(overlay);
+  SDL_SetRenderTarget(drv->renderer, NULL);
   SDL_SetRenderDrawColor(drv->renderer, 0, 0, 0, 255);
 }
 

core/embed/io/power_manager/unix/power_manager.c

@@ -23,8 +23,9 @@
 #include <io/power_manager.h>
 #include <io/unix/sdl_display.h>
 
-#include <SDL.h>
-#include <SDL2/SDL_events.h>
+#include <SDL3/SDL.h>
+#include <stdlib.h>
+#include "SDL3/SDL_events.h"
 
 #include "../power_manager_poll.h"
 
@@ -76,11 +77,12 @@ pm_status_t pm_suspend(wakeup_flags_t* wakeup_reason) {
 
   SDL_Event event;
   while (SDL_WaitEvent(&event)) {
-    if (event.type == SDL_QUIT) {
+    if (event.type == SDL_EVENT_QUIT) {
       exit(1);
     }
-    if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP ||
-        event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) {
+    if (event.type == SDL_EVENT_KEY_DOWN || event.type == SDL_EVENT_KEY_UP ||
+        event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
+        event.type == SDL_EVENT_MOUSE_BUTTON_UP) {
       *wakeup_reason = WAKEUP_FLAG_BUTTON;
       break;
     }